java之旅 （第六天） 一维数组拓展 二维数组及拓展 数组工具类 java传参类型

一维数组：

一维数组：

int [] arr=new int [10];(动态初始化)

int [] arr=new int[]{1,2,3};（静态初始化）

 

数组常见的问题：

java.lang.ArrayIndexOutOfBoundsException: 5 : 数组越界异常

原因:找不到一个为5的索引。

java.lang.NullPointerException:空指针异常

原因:该数组肯定已经不再指向堆内存，或者访问了 一个为空的数组。

  举例：

int [] arr = {1,285,15,15};

    System.out.println(arr[5]);

arr = null;

System.out.println(arr[0])；

补充：

数字类型的数据初始化为 0

boolean类型数据初始化为false

char类型数据初始化为 ‘\u0000’(int类型输出就 是0)

引用类型数据初始化为 null（String也是引用类 型）

 

数组元素逆序：

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

int temp;

  for（int i=0,b=length;i<b;i++,b--）  

{

temp=arr[i];

arr[i]=arr[b];

arr[b]=temp;

}

分析：

当数组元素为偶数时，最后一次循环最中间的两个数 交换，然后i>b,跳出循环

当数组元素为奇数时，最后i与b都会同时变为最中间 的数的下标，此时，i=b，跳出循环

因为i 与 b的关系只有上面两种，分别对应奇数个数 的数组与偶数个数的数组，

 

数组遍历：

//强哥原创方法，好理解，但需要多开一个数组

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

for (int i = 0; i < arr.length; i++)

{

System.out.print(arr[i];

  }

注：当想访问数组最后一个元素时，记得(length-1)

因为，数组从0开始，最后一个元素的下标比数组长 度少1

 

数组去重：（新数组不能有多余的空间浪费）

int []arr=new int[]   {1,2,3,4,5,3,6,9,3,3,3,2,1};  //数组的静态初始

int []compare =new int[arr.length];//过渡数组

int count=1;  //用于计数compare中有多少个元素

int b=0;       //用于装载compare中的下标

 

compare[0]=arr[0];//过渡数组的一地个元素赋值

 

for(int i=1;i<arr.length;i++) //两数组对比

{

     for(b=0;b<count;b++)//原数组第二个元素开始比较 

{

if(arr[i]==compare[b]) //有重复的跳出循环

{

break;

}

}

 

if(b==count)  //如果没有重复的值，添加进过渡数组

{

count++; //最后的数组长度+1，过渡数组中元素也+1

compare[b]=arr[i];

}

}

 

int [] result=new int[count]; //结果数组

 

for(int i=0;i<count;i++) //把过渡数组传给结果数组

{

result[i]=compare[i]; 

}

 

System.out.println(result.length);

for(int i=0;i<result.length;i++)//遍历输出结果

{

System.out.println(result[i]);

}

}

}

注：

1.需要是三个数组，arr原数组，compare过渡数组 （长度与原数组一样，用去筛除重复元素），result 数组转载最终结果，且没有多余的空间浪费

2.int b（第二个循环控制变量）必须在for循环外定 义，因为需要用到其与count作比较，把不重复的元 素添加进过度数组中

3.count不仅表示过度数组中元素多少，刚好也是结 果数组的长度

 

数组排序：

快速排序（选择排序）：  //从大到小

int []arr=new int[]   {1,2,3,4,5,3,6,9,3,3,3,2,1};  //数组的静态初始

int temp;

for（int i=0,b=0；i<arr.length-1;i++）//最后一个是 倒数第二

{

for(b=i+1;b<arr.length;b++)  //最后一个是倒数 第一

{

if(arr[i]>arr[b])

{

temp=arr[i];

arr[i]=arr[b];

arr[b]=arr[i];

}

}

}

 

冒泡排序：            //从大到小

int []arr=new int[]   {1,2,3,4,5,3,6,9,3,3,3,2,1};  //数组的静态初始

int temp;

 

//控制循环轮数

for（int i=0,b=0；i<arr.length-1;i++）

{

for(b=0;b<arr.length-i-1;b++)  //控制比较的下 标

{

if(arr[b]>arr[b+1])

{

temp=arr[b+1];

arr[b+1]=arr[b];

arr[b]=temp;

}

}

}

 

选择排序 冒泡排序 对比：

1.选择排序比较简单，逻辑比较清楚。冒泡排序面试 会考

2.选择排序把最小（最大）的放在前面，第一轮循环 是控制固定不动的位置，第二轮是控制固定位置后面 的数进行比较。

冒泡排序把最小（最大）的放在最后面，从后面开始 往前推。第一轮循环是控制比较的次数，第二轮 循 环是控制所要固定的最后一个位置

3.选择排序经常用，冒泡排序要记住！！！

 

 

数组工具类：

Arrays类：

import java.util.Arrays;

 

equals(array1,array2)；

判断两个数组是否相同，相等就返回true

举例：

String[] str1={"1","2","3"};

String[] str2={"1","2",new String("3")};

System.out.println(Arrays.equals(str1,str2));

//结果是：true

 

void sort(array)

对数组array的元素进行升序排列，从小到大

举例：

int[] score ={79,65,93,64,88};

Arrays.sort(score);//返回值是void 不包输出

注：去重没有自带方法，只能自己写

 

 

二维数组：

格式:

数据类型[][] 数组名 = new int[m][n];

m：表示这个二维数组里面有多少个一维数组

n:表示每一个一维数组里面有多少个元素值

注意:

以下格式也能够定义二维数组:

a.数据类型 数组名[][] = new 数据类型[m][n];

b.数据类型[]数组名[]  = new 数据类型[m][n];

b.注意以下格式:

int [] x;

int [] y [];  //夹心饼也能定义二维数组

int []x,y[];

举例：

int [][] arr  = new int[3][2];//这种写法是只有 指定有多少个一维数组，但是并没有给一维数组进行 空间的分配

System.out.println(arr);//二维地址的地址值

System.out.println(arr[0]);//一维地址的地址值

System.out.println(arr[1]);//一维地址的地址值

System.out.println(arr[2]);//一维地址的地址值

 

//取出元素值

System.out.println(arr[0][0]);

System.out.println(arr[0][1]);

 

int [][] arr = new int [m][];

m:表示这个二维数组里面有m个一维数组

但是没有给出每个一维数组里面有多少个元素(没有 为一维数组分配空间)

 

二维数组的静态初始:

基本格式:

数据类型[][] 数组名 = new 数据类型[][]{{元素 1},{元素1,元素2},{元素1,元素2}};

简化格式:

数据类型[][] 数组名 = {{元素1},{元素1,元素 2},{元素1,元素2}};

注：

1.静态初始化可以定义每一个一维数组的长度

2.第二种，是省略了new 但还是在堆中新开辟了空间

3.错误写法 不要静态和动态混合

int [][] arr = new int [4][5]{{元素1},{元素1, 元素2},{元素1,元素2}};

 

 

 

 

传参方式：

java方法中形式参数传递的问题:

基本数据类型:形式参数的改变不会影响到实际参数 （传值）

引用数据类型:形式参数的改变会直接影响到你的 实 际参数（传址） String 数组都属于引用类型

注：

1.在子方法中的变量都是在堆中开辟的内存！！

2.除了基本类型都是引用类型