java数组

java数组
数组：相同类型数据的有序集合

(1)数组：是引用数据类型；
(2)new：关键字，在堆内存开辟空间；
成员变量（堆内存）：有默认值
局部变量（栈内存）：没有默认值，使用之前一定手动赋值；
(3)引用变量赋值：
int[] arr1={6,7,8};
int[] arr2=arr1;//引用变量，把arr1的值赋给arr2;
arr1和arr2指向的是堆内存的同一块空间。
数组特性：数组的特性：相同类型数据的有序集合
(1)数组的定义：int[] scoreArr=new int[10];
(2)数组是引用数据类型：scoreArr是引用类型的变量，new关键字在堆内存里开辟空间。
(3)如何访问数组元素呢？数组是有顺序的，下标（索引）顺序。索引编号从0开始，到【数组元素的个数-1】。最大索引:数组长度-1。
scoreArr[0]=97;
数组名[索引值]；
(4)数组的元素类型必须和声明的类型一致，数组里元素类型是相同的，不能是混合类型。
(5)数组可以是:基本数据类型和引用数据类型(如String)。
(6)数组的长度:scoreArr.length;
数组名.length;
(7)数组长度一旦声明，就固定了。
(8)数组元素有默认值：
int:0;
double:0.0;
char:‘\u0000’;
boolean:false;
String:null;—>引用数据类型的数组，默认值都是null。
数组初始化：
静态初始化：数组的声明，分配空间，赋值在一条语句里；
int[] scoreArr=new int[]{1,2,3,4,5};
int[] scoreArr={1,2,3,4,5};
2.动态初始化：数组的声明，分配空间，赋值【不】在一条语句里；
int[] scoreArr;//声明一个数组变量；
scoreArr=new int[5];//分配空间；

   //给数组元素赋值；
   scoreArr[0]=1;
   scoreArr[1]=5;
   scoreArr[2]=5;
		3.默认初始化：int[] scoreArr=new int[10];

数组声明的多种方法：
int[] scoreArr=new int[10];
int scoreArr[]=new int[10];
int[][] scoreArr;
int scoreArr[][];
int[] scoreArr[];
遍历数组
普通for循环 通过表历数组索引遍历数组
int[] array=new int[]{1,2,3,23,42,23253,1233,21341,21};

    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
		for-each循环： (1)jdk1.5引入；

(2)优点：简单；
(3)缺点：不能进行与索引有关的操作；
(4)如果只需遍历数组，用for-each循环
int[] array=new int[]{1,2,3,23,42,23253,1233,21341,21};

    for (int i:array
         ) {
        System.out.println(i);
    }
	数组常见异常
		数组越界异常：(1)java.lang.ArrayIndexOutOfBoundsException: 6:
			    int[] scoreArr;
   scoreArr=new int[5];//分配空间；
   
   //给数组元素赋值；
   scoreArr[0]=1;
   scoreArr[1]=5;
   scoreArr[2]=5;
   
   //java.lang.ArrayIndexOutOfBoundsException: 6:数组越界异常。
   System.out.println(scoreArr[6]);
		空指针异常： java.lang.NullPointerException
			 int[] scoreArr1=null;//声明一个数组变量；
   System.out.println(scoreArr1.length);// java.lang.NullPointerException;
	数组查询
		 (1)按【索引】查询；效率高，数组在内存中分配的是【连续的】空间；
找到索引为i的元素的地址=首地址+每个元素所占的空间大小*索引值；
			   //定义一个数组；

int[] scoreArr={97,85,96,99,59,60,99,100,95,65};

   //(1)查第6位同学的分数；
   System.out.println(scoreArr[5]);
		 (2)按【值】查询：效率低，
从头开始依次查每个元素；
    1.可能查到；
    2.可能查不到；
    3.如果数组是有序的，可以用二分法查询。
			//定义一个数组；

int[] scoreArr={97,85,96,99,59,60,99,100,95,65};

   //查询有没有100分；
     int index=-1;
     for(int i=0;i<scoreArr.length;i++){
     
       if(scoreArr[i]==100){
              index=i;//把i赋给index;
              break;
           }
     
     }
     
     //判断index的值；
     // if(index==-1){
     
       // System.out.println("没有100分的。");
     
     // }else{
     
      // System.out.println("有100分的。");
     // }
     
      System.out.println(index==-1?"没有100分的。":"有100分的。");

}
数组修改
按索引修改
(1)按【索引】修改；效率高，数组在内存中分配的是【连续的】空间；
找到索引为i的元素的地址=首地址+每个元素所占的空间大小*索引值；
//定义一个数组；
int[] scoreArr={97,85,96,99,59,60,99,100,95,65};

   //(1)修改第6位同学的分数；
   scoreArr[5]=100;
   System.out.println(scoreArr[5]);
   
		按值修改
			(2)按【值】修改：效率低，
从头开始依次查每个元素；符合条件的元素修改。
				 //(2)修改:把59分提成60分；
     int index=-1;
     for(int i=0;i<scoreArr.length;i++){
     
       if(scoreArr[i]==59){
              scoreArr[i]=60;
           }
     
     }

	数组删除
		 //定义一个数组；

int[] scoreArr={150,99,59,100,120};

   //1.首先得到59的索引；为2;
   int index=2;
   
   //2.index为2的之前的元素不变；
   //3.index为2之后的元素：后一个元素的值赋给前一个元素；
   for(int i=index;i<scoreArr.length-1;i++){
       scoreArr[i]=scoreArr[i+1];
   }
   
   //4.把最后一个元素赋值为0;
   scoreArr[scoreArr.length-1]=0;
	数组增加
		     int a[]={150,99,100,120,0};
           int index=2;
           for(int i=a.length-1;i>index;i--)
           {
                   a[i]=a[i-1];
                   
           }
           a[index]=59;
   
	数组优缺点
		数组的优点：

按索引查询，效率高；

数组的缺点：
(1)按数值查询，效率低；
(2)长度固定；
(3)模拟添加和删除，效率低；可能会引起大量元素的位移。
Arrays工具类;
/*
功能：Arrays工具类;

（1）Arrays.toString(arr): 简单遍历数组；
（2）Arrays.sort(arr);给数组元素排序，升序；
（3）Arrays.binarySearch(arr,52);arr一定是排好序的；
（4）Arrays.equals(arr,arr2);
（5）Arrays.fill(arr,10);
（6）Arrays.copyOf(arr, 10);

*/
//定义一个一维数组；
int[] arr={52,87,33,96,59};

   Arrays.sort(arr);//{33,52,59,87,96};
   //如果要查的值在数组里存在，返回的是索引值；如果不存在，返回-(应该存在的索引位置+1);
   int index=Arrays.binarySearch(arr,60);
   
   System.out.println(index);
   
   int[] arr2={33,52,59,87,96};
   
   System.out.println(Arrays.equals(arr,arr2));//比较数组内容，元素的内容和顺序都得一致；
   
   //Arrays.fill(arr,10);//数组元素全部变成10;
   //Arrays.fill(arr,0,2,10);//索引范围：含头不含尾；
   
   int[] arr3=Arrays.copyOf(arr, 10);
	二维数组
		定长二维数组：  int[][]        scoreArr=new int[3][4];
		不定长二维数组： //定义一个二维数组；

int[][] scoreArr=new int[3][];//先指定第一维度的长度；
//给二维数组赋值；
scoreArr[0]=new int[3];//给第二维度分配空间；
scoreArr[0][0]=98;
scoreArr[0][1]=97;
scoreArr[0][2]=99;

   scoreArr[1]=new int[4];//给第二维度分配空间；
   scoreArr[1][2]=89;
   scoreArr[1][3]=80;
   
   scoreArr[2]=new int[5];//给第二维度分配空间；
   
   //遍历二维数组；双重循环；
   for(int i=0;i<scoreArr.length;i++){
       System.out.println("第"+(i+1)+"个班的学生成绩：");
      for(int j=0;j<scoreArr[i].length;j++){
       System.out.print(scoreArr[i][j]+"\t");  
      }

	冒泡排序
		冒泡排序1： //定义一个数组；

int[] arr={30,25,40,15,100,60,20};

   //排序;
   for(int i=1;i<arr.length;i++){//控制趟数；
   
       //每趟所做的操作；从第1个元素开始，依次比较相邻的两个元素，如果符合排序条件，交换两个元素的值；
           for(int j=0;j<arr.length-1;j++){
           
              //符合条件：交换；
              if(arr[j]>arr[j+1]){
             
                 int temp=0;
                     temp=arr[j];
                     arr[j]=arr[j+1];
                     arr[j+1]=temp;
                     
              }
		冒泡排序2： //定义一个数组；

int[] arr={30,25,40,15,100,60,20};

   //排序;
   for(int i=1;i<arr.length;i++){//控制趟数；
   
       //每趟所做的操作；从第1个元素开始，依次比较相邻的两个元素，如果符合排序条件，交换两个元素的值；
           for(int j=0;j<arr.length-i;j++){
           
              //符合条件：交换；
              if(arr[j]>arr[j+1]){
             
                 int temp=0;
                     temp=arr[j];
                     arr[j]=arr[j+1];
                     arr[j+1]=temp;
                     
              }
           
           }
   
   }