自学Java第四章——《数组》

2020-02-12 16:04:27来源:博客园 阅读 ()

容器云强势上线!快速搭建集群,上万Linux镜像随意使用

自学Java第四章——《数组》

4.1 数组的相关概念和名词(了解)

1、数组(array):

一组具有相同数据类型的数据的按照一定顺序排列的集合。

把有限的几个相同类型的变量使用一个名称来进行统一管理。

2、数组名:

(1)这个数组名,代表的是一组数

(2)这个数组名中存储的整个数组的“首地址”

3、下标(index):

我们使用编号、索引、下标来区别表示一组数当中某一个。

范围:[0,数组长度-1]

例如:for(int i = 0; i<arr.length; i++){}

4、元素(element):

这一组中的的每一个数据都是元素。

如何表示数组元素? 数组名[下标]

5、数组的长度(length)

数组中元素的总个数。

如何获取数组长度? 数组名.length

注意:名称是为了沟通的方便,概念不用一字不落背下来

4.2 数组的相关语法

4.2.1 数组的声明

语法格式:

 //推荐
元素的数据类型[] 数组名;
?
//也对,但是不推荐
元素的数据类型  数组名[];

示例:

//要存储一组整数
int[] array;
?
//要存储一组单字符
char[] array;
?
//要存储一组字符串
String[] array;

4.2.2 数组的初始化

初始化的目的:(1)确定数组的长度(2)为元素赋值

两种初始化方式:

1、动态初始化

语法格式:

//指定数组长度
数组名 = new 元素的数据类型[长度];
?
//为元素赋值
数组名[下标] = 值; //这个值可以是个常量值,也可以是个表达式的计算结果,也可以是键盘输入的
?
//如果每个元素的赋值比较有规律,通常使用for循环赋值
for(int i=0; i<长度; i++){
   数组名[下标] = 值;
}

问:如果只指定数组长度,没有为元素手动赋值,那么元素有值吗?

有默认值

(1)基本数据类型

byte,short,int,long:0

float,double:0.0

char:\u0000

boolean:false

(2)引用数据类型

统统都是null

 

2、静态初始化

语法格式:

数组名 = new 元素的数据类型[]{值列表};
?
//int[] arr = new int[5]{1,2,3,4,5};//错误的
?
//更简洁
//当声明与静态初始化一起完成时,可以简化
元素的数据类型[] 数组名 = {值列表};

适用场合:

当数组的元素是已知的有限个时,可以使用静态初始化。

示例代码:

String[] weeks = {"monday","tuesday","wednesday","thursday","friday","saturday","sunday"};
?
int[] daysOfMonths = {31,28,31,30,31,30,31,31,30,31,30,31};
?
char[] letters = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};

 

4.2.3 数组的遍历

for循环遍历数组:

for(int i=0; i<数组名.lenght; i++){
   //或赋值
   数组名[i] = 值;
   //或显示
   System.out.println(数组名[i])
   //或其他操作
   //例如:判断是否是偶数
   if(数组名[i]%2==0){
         //...
  }
}

 

4.2.4 数组的内存分析

元素是基本数据类型的一维数组内存分析:

int[] arr = {1,2,3,4,5};

 

int[] arr = new int[5];
for(int i=0; i<arr.length; i++){
   arr[i] = i+1;
}

 

 

4.3 数组的相关算法

4.3.1 数组找最值

1、数组中找最值

思路:

(1)先假设第一个元素最大/最小

(2)然后用max/min与后面的元素一一比较

示例代码:

int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
   if(arr[i] > max){
       max = arr[i];
  }
}

2、数组中找最值及其下标

情况一:找最值及其第一次出现的下标

思路:

(1)先假设第一个元素最大/最小

(2)然后用max/min与后面的元素一一比较

示例代码:

int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
int index = 0;
for(int i=1; i<arr.length; i++){
   if(arr[i] > max){
       max = arr[i];
       index = i;
  }
}

int[] arr = {4,5,6,1,9};
//找最大值
int maxIndex = 0;
for(int i=1; i<arr.length; i++){
   if(arr[i] > arr[maxIndex]){
       maxIndex = i;
  }
}
System.out.println("最大值:" + arr[maxIndex]);

 

情况二:找最值及其所有最值的下标(即可能最大值重复)

思路:

(1)先找最大值

①假设第一个元素最大

②用max与后面的元素一一比较

(2)遍历数组,看哪些元素和最大值是一样的

示例代码:

int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
   if(arr[i] > max){
       max = arr[i];
  }
}
?
//遍历数组,看哪些元素和最大值是一样的
for(int i=0; i<arr.length; i++){
   if(max == arr[i]){
       System.out.print(i+"\t");
  }
}

 

4.3.2 数组统计:求总和、均值、统计偶数个数等

思路:遍历数组,挨个的累加,判断每一个元素

示例代码:

int[] arr = {4,5,6,1,9};
//求总和、均值
int sum = 0;//因为0加上任何数都不影响结果
for(int i=0; i<arr.length; i++){
   sum += arr[i];
}
double avg = (double)sum/arr.length;

示例代码2:

int[] arr = {4,5,6,1,9};
?
//求总乘积
long result = 1;//因为1乘以任何数都不影响结果
for(int i=0; i<arr.length; i++){
   result *= arr[i];
}

示例代码3:

int[] arr = {4,5,6,1,9};
//统计偶数个数
int even = 0;
for(int i=0; i<arr.length; i++){
   if(arr[i]%2==0){
       even++;
  }
}

 

4.3.3 反转

方法有两种:

1、借助一个新数组

2、首尾对应位置交换

第一种方式示例代码:

int[] arr = {1,2,3,4,5,6,7,8,9};
?
//(1)先创建一个新数组
int[] newArr = new int[arr.length];
?
//(2)复制元素
int len = arr.length;
for(int i=0; i<newArr.length; i++){
   newArr[i] = arr[len -1 - i];
}
?
//(3)舍弃旧的,让arr指向新数组
arr = newArr;//这里把新数组的首地址赋值给了arr
?
//(4)遍历显示
for(int i=0; i<arr.length; i++){
   System.out.println(arr[i]);
}

第二种方式示例代码:

int[] arr = {1,2,3,4,5,6,7,8,9};

//(1)计算要交换的次数:  次数 = arr.length/2
//(2)首尾交换
for(int i=0; i<arr.length/2; i++){//循环的次数就是交换的次数
    //首  与  尾交换
    int temp = arr[i];
    arr[i] = arr[arr.length-1-i];
	arr[arr.length-1-i] = temp;
}

//(3)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

4.3.4 复制

应用场景:

1、扩容

2、备份

3、截取

示例代码:扩容

int[] arr = {1,2,3,4,5,6,7,8,9};
?
//如果要把arr数组扩容,增加1个位置
//(1)先创建一个新数组,它的长度 = 旧数组的长度+1
int[] newArr = new int[arr.length + 1];
?
//(2)复制元素
//注意:i<arr.length   因位arr比newArr短,避免下标越界
for(int i=0; i<arr.length; i++){
   newArr[i] = arr[i];
}
?
//(3)把新元素添加到newArr的最后
newArr[newArr.length-1] = 新值;
?
//(4)如果下面继续使用arr,可以让arr指向新数组
arr = newArr;
?
//(4)遍历显示
for(int i=0; i<arr.length; i++){
   System.out.println(arr[i]);
}

示例代码:备份

int[] arr = {1,2,3,4,5,6,7,8,9};
?
//1、创建一个长度和原来的数组一样的新数组
int[] newArr = new int[arr.length];
?
//2、复制元素
for(int i=0; i<arr.length; i++){
   newArr[i] = arr[i];
}
?
//3、遍历显示
for(int i=0; i<arr.length; i++){
   System.out.println(arr[i]);
}

示例代码:截取

int[] arr = {1,2,3,4,5,6,7,8,9};
?
int start = 2;
int end = 5;
?
//1、创建一个新数组,新数组的长度 = end-start + 1;
int[] newArr = new int[end-start+1];
?
//2、赋值元素
for(int i=0; i<newArr.length; i++){
   newArr[i] = arr[start + i];
}
?
//3、遍历显示
for(int i=0; i<newArr.length; i++){
   System.out.println(newArr[i]);
}

4.3.5 查找

查找分为两种:

1、顺序查找:挨个看

对数组没要求

2、二分查找:对折对折再对折

对数组有要求,元素必须有大小顺序的

顺序查找示例代码:

int[] arr = {4,5,6,1,9};
int value = 1;
int index = -1;
?
for(int i=0; i<arr.length; i++){
   if(arr[i] == value){
       index = i;
       break;
  }
}
?
if(index==-1){
   System.out.println(value + "不存在");
}else{
   System.out.println(value + "的下标是" + index);
}

二分查找示例代码:

/*
2、编写代码,使用二分查找法在数组中查找 int value = 2;是否存在,如果存在显示下标,不存在显示不存在。
已知数组:int[] arr = {1,2,3,4,5,6,7,8,9,10};
*/
class Exam2{
public static void main(String[] args){
int[] arr = {1,2,3,4,5,6,7,8,9};//数组是有序的
int value = 2;

       int index = -1;
int left = 0;
       int right = arr.length - 1;
       int mid = (left + right)/2;
       while(left<=right){
           //找到结束
           if(value == arr[mid]){
               index = mid;
               break;
          }//没找到
           else if(value > arr[mid]){//往右继续查找
               //移动左边界,使得mid往右移动
               left = mid + 1;
          }else if(value < arr[mid]){//往左边继续查找
               right = mid - 1;
          }
           
           mid = (left + right)/2;
      }
       
       if(index==-1){
  System.out.println(value + "不存在");
}else{
  System.out.println(value + "的下标是" + index);
}
       
}
}

使用for

class Exam2{
public static void main(String[] args){
int[] arr = {1,2,3,4,5,6,7,8,9};//数组是有序的
int value = 2;

       int index = -1;
       
       for(int left=0,right=arr.length-1,mid = (left+right)/2; left<=right; mid = (left + right)/2){
            //找到结束
           if(value == arr[mid]){
               index = mid;
               break;
          }//没找到
           else if(value > arr[mid]){//往右继续查找
               //移动左边界,使得mid往右移动
               left = mid + 1;
          }else if(value < arr[mid]){//往左边继续查找
               right = mid - 1;
          }
      }
       

       
       if(index==-1){
  System.out.println(value + "不存在");
}else{
  System.out.println(value + "的下标是" + index);
}
       
}
}

 

4.3.6 排序

数组的排序算法有千万种,我们只讲了两种:

1、冒泡排序

2、简单的直接排序

示例代码:冒泡:从小到大,从左到右两两比较

int[] arr = {5,4,6,3,1};
for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
   /*
   第1轮,i=1,从左到右两两比较,arr[0]与arr[1]。。。。。arr[3]与arr[4]
   第2轮,i=2,从左到右两两比较,arr[0]与arr[1]。。。。。arr[2]与arr[3]
   ...
  arr[j]与arr[j+1]比较
   找两个关键点:(1)j的起始值:0(2)找j的终止值,依次是3,2,1,0,得出j<arr.length-i
   */
   for(int j=0; j<arr.length-i; j++){
       //两两比较
       //从小到大,说明前面的比后面的大,就交换
       if(arr[j] > arr[j+1]){
           int temp = arr[j];
           arr[j] = arr[j+1];
           arr[j+1] = temp;
      }
  }
}

示例代码:从大到小,从右到左

char[] arr = {'h','e','l','l','o','j','a','v','a'};
for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
   /*
   第1轮,i=1,从右到左两两比较,arr[8]与arr[7],arr[7]与arr[6]....arr[1]与arr[0]
   第2轮,i=2,从右到左两两比较,arr[8]与arr[7],arr[7]与arr[6]....arr[2]与arr[1]
   ...
   第8轮,i=8,从右到左两两比较,arr[8]与arr[7]
    arr[j]与arr[j-1]
   找两个关键点:(1)j的起始值:8(2)找j的终止值,依次是1,2,3,。。。8,得出j>=i
   */
   for(int j=8; j>=i; j--){
       //从大到小,后面的元素 > 前面的元素,就交换
       if(arr[j]>arr[j-1]){
           int temp = arr[j];
           arr[j] = arr[j-1];
           arr[j-1] = temp;
      }
  }
}

示例代码:简单的直接选择排序

int[] arr = {3,2,6,1,8};
?
for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
   //(1)找出本轮未排序元素中的最值
   /*
   未排序元素:
   第1轮:i=1,未排序,[0,4]
   第2轮:i=2,未排序,[1,4]
   ...
   
   每一轮未排序元素的起始下标:0,1,2,3,正好是i-1的
   未排序的后面的元素依次:
   第1轮:[1,4] j=1,2,3,4
   第2轮:[2,4] j=2,3,4
   第3轮:[3,4] j=3,4
   第4轮:[4,4] j=4
   j的起点是i,终点都是4
   */
   int max = arr[i-1];
   int index = i-1;
   for(int j=i; j<arr.length; j++){
       if(arr[j] > max){
           max = arr[j];
           index = j;
      }
  }
   
   //(2)如果这个最值没有在它应该在的位置,就与这个位置的元素交换
   /*
   第1轮,最大值应该在[0]
   第2轮,最大值应该在[1]
   第3轮,最大值应该在[2]
   第4轮,最大值应该在[3]
   正好是i-1的值
   */
   if(index != i-1){
       //交换arr[i-1]与arr[index]
       int temp = arr[i-1];
       arr[i-1] = arr[index];
       arr[index] = temp;
  }
}
?
?
?
//显示结果
for(int i=0; i<arr.length; i++){
System.out.print(arr[i]);
}

 

4.4 二维数组

二维数组的标记:[][]

4.4.1 相关的表示方式

(1)二维数组的长度/行数:

二维数组名.length

(2)二维数组的其中一行:

二维数组名[行下标]

行下标的范围:[0, 二维数组名.length-1]

(3)每一行的列数:

二维数组名[行下标].length

因为二维数组的每一行是一个一维数组

(4)每一个元素

二维数组名[行下标][列下标]

4.4.2 二维数组的声明和初始化

1、二维数组的声明

  //推荐
 元素的数据类型[][] 二维数组的名称;
?
//不推荐
元素的数据类型  二维数组名[][];
//不推荐
 元素的数据类型[]  二维数组名[];

面试:

int[] x, y[];
//x是一维数组,y是二维数组

 

2、二维数组的初始化

(1)静态初始化

二维数组名 = new 元素的数据类型[][]{
{第一行的值列表},
{第二行的值列表},
...
{第n行的值列表}
};

//如果声明与静态初始化一起完成
元素的数据类型[][] 二维数组的名称 = {
{第一行的值列表},
{第二行的值列表},
...
{第n行的值列表}
};

(2)动态初始化(不规则:每一行的列数可能不一样)

//(1)先确定总行数
二维数组名 = new 元素的数据类型[总行数][];
?
//(2)再确定每一行的列数
二维数组名[行下标] = new 元素的数据类型[该行的总列数];
?
//(3)再为元素赋值
二维数组名[行下标][列下标] = 值;

(3)动态初始化(规则:每一行的列数是相同的)

//(1)确定行数和列数
二维数组名 = new 元素的数据类型[总行数][每一行的列数];
?
//(2)再为元素赋值
二维数组名[行下标][列下标] = 值;

 

4.4.3 二维数组的遍历

for(int i=0; i<二维数组名.length; i++){
  for(int j=0; j<二维数组名[i].length; j++){
      System.out.print(二维数组名[i][j]);
  }
  System.out.println();
}

 


原文链接:https://www.cnblogs.com/wlx6/p/12300644.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:springboot去除内嵌tomcat和打包在tomcat中运行需要做的步骤

下一篇:SpringMVC重定向(redirect)传参数,前端EL表达式接受值