java--summary3数组

1.一维数组
数组作为对象允许使用new关键字进行内存分配，在使用数组之前，必须定义数组变量所属的类型–声明数组
格式：两种方法
数组元素类型 数组名字[]；
数组元素类型[] 数组名字；
eg. int arr[];
String[] str;
声明数组后还不能访问他的任何元素，要想真正使用数组还需要给他分配内存空间，且分配内存空间还必须指明数组的长度
数组名字=new 数组元素类型[数组元素的个数]

eg.arr=new int[5];
使用new为数组分配内存的时候，数组中的各个元素的初始值都为0；
创建数组和分配内存不一定要分开执行，可以创建数组时直接为变量赋值格式：
数组元素类型 数组名[]=new 数组元素类型[数组元素的个数]
eg. int month[]=new int [12];

2.初始化一维数组两种方式初始化一维数组
int arr[]=new int[]{4,25,3,26,5,7,9,21,10,14};
int arr2[]={4,25};//编译器将根据初始化的数量来自动计算数组的长度并创建数组

package com.company;
        public class Main {
            public static void main(String[] args) {      
                      int num[]={1,2,3,4,5,6,7,8,9,10};      
                                int sum=0;         
                                       System.out.println("一维数组中个元素的和是：");                       for(int i=0;i<10;i++){       
                                     if(i==9){       
                                                    System.out.print(num[i]+"=");           
                                                         }else{       
           System.out.print(num[i]+"+");              
               }             
                    sum+=num[i];         
                         }      
                         System.out.print(sum);    }}

1+2+3+4+5+6+7+8+9+10=55

//输出数组最小的值package com.company;public class Main {  
  public static void main(String[] args) {     
     int num[]={3,2,1,6,7,100};      
       int min=num[0];      
         for(int i=1;i<6;i++)        
             if(num[i]<min)           
                  min=num[i];   
                  System.out.println(min);  
                    }}

3.二维数组
声明二维数组有两种：
数组元素类型 数组名字[][];
数组元素类型[][] 数组名字
int myarr[][];
声明数组后还不能访问他的任何元素，要想真正使用数组还需要给他分配内存空间，且分配内存空间二维数组可以由多个一维数组所组成，在给二维数组分配空间时，可以为这些一维数组同时分配相同的内存。第一个中括号中的数字是一维数组的个数，第二个中括号中的数字是一维数组的长度a=new int[2][4];为二维数组分配内存，分配后二维数组a拥有两个长度是4的一维数组
length=2 length=4
a[0] — a[0][0] a[0][1] a[0][2] a[0][3]

                   length=4

a[1] — a[1][0] a[1][1] a[1][2] a[1][3]

在给二维数组分配内存时，还可以对其每一个一维数组单独分配内存空间，且分配的内存可以不同，在第一个中括号中定义一维数组的个数，然后就利用一维数组分配内存的方法分配内存

eg.a=new int[2][];
a[0]=new int[2];
a[1]=new int [3];
为二维数组分配内存，先给二维数组分配2个一维数组，然后对第一个一维数组分配内存2，对第二个二维数组分配内存3
length=2 length=2 a[0]---- a[0][0] a[0][1]
length=3 a[1]-----a[1][0] a[1][1] a[1][2]

4.二维数组的初始化
type arrayname[][]={value1,value2,value3—valuen}int myarr[][]={{2,10},{3,10});对于整形二维数组，创建成功后会给数组的每个元素赋值为0；

package com.company;
public class Main {
    public static void main(String[] args) { 
        int a[][]=new int[3][5];
             System.out.println("输出3行5列的数组：");     
             for (int i=0;i<a.length;i++) {
                      for (int j = 0; j < a[i].length; j++)   
                                System.out.print(a[i][j] + " ");
                                         System.out.println();
                                              }    }}
                                  输出3行5列的数组：0 0 0 0 0
                                                                   0 0 0 0 0
                                                                    0 0 0 0 0 

4.三维数组初始化三维数组时，由3层大括号进行初始化。package com.company;public class Main {
public static void main(String[] args) {
int arr[][][]=new int[][][]{
{{1,2,3},{4,5,6}}, {{7,8,9},{10,11,12}}, {{13,14,15},{16,17,18}}}; for(int i=0;i<arr.length;i++){
System.out.println(“三维数组的的第”+(i+1)+“个元素是一个”+arr[0].length+“维数组，内容如下：”);
for(int j=0;j<arr[0].length;j++) {
for (int k = 0; k < arr[0][0].length; k++) {
System.out.print(arr[i][j][k] + “\t”); } System.out.println(); } } }}三维数组的的第1个元素是一个2维数组，内容如下：1 2 3 4 5 6 三维数组的的第2个元素是一个2维数组，内容如下：7 8 9 10 11 12 三维数组的的第3个元素是一个2维数组，内容如下：13 14 15 16 17 18

求二维数组的对角线之和（迹）    public static void main(String[] args) {        int arr[][] = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};        int tr = 0;        for (int i = 0; i < arr.length; i++) {            for (int j = 0; j < arr.length; j++) {                System.out.print(arr[i][j] + " ");            }            System.out.println();
        }        for (int i = 0; i < arr.length; i++) {            tr += arr[i][i];        }        System.out.println("tr:" + tr);
    }}
数组的基本操作1.遍历数组遍历一维数组package com.company;public class Main {    public static void main(String[] args) {
       int day[]=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};       for(int i=0;i<12;i++){           System.out.print((i+1)+"月有"+day[i]+"天"+"\t");           if((i+1)%3==0){               System.out.println();           }       }
    }}1月有31天	2月有28天	3月有31天	4月有30天	5月有31天	6月有30天	7月有31天	8月有31天	9月有30天	10月有31天	11月有30天	12月有31天	


package com.company;//遍历二维数组public class Main {    public static void main(String[] args) {        int b[][] = new int[][]{{1}, {2, 3}, {4, 5, 6}};        System.out.println("二维数组是：");        for (int k = 0; k < b.length; k++) {            for (int c = 0; c < b[k].length; c++) {                System.out.print(b[k][c] + "　");            }            System.out.print("\n");        }    }}二维数组是：1　2　3　4　5　6　
填充替换数组元素1.fill(int[] a,int value)a:要进行元素替换的数组value:要储存数组中所有元素的值返回值：填充后的数组package com.company;import java.util.Arrays;public class Main {    public static void main(String[] args) {             int arr[]=new int[5];             Arrays.fill(arr,8);             for(int i=0;i<arr.length;i++){                 System.out.println("第"+(i+1)+"个元素是："+arr[i]);    }
    }}2.fill(int[] a,int fromIndex,int toIndex,int value)a:要进行元素替换的数组fromIndex:要使用指定填充的第一个元素的索引（包括）toIndex：要使用指定填充的最后一个元素的索引（不包括）value:要储存数组中所有元素的值返回值：填充后的数组如果toIndex==fromIndex，则填充范围为空
package com.company;import java.util.Arrays;public class Main {    public static void main(String[] args) {            int arr[]=new int[]{45,12,2,10,1};            Arrays.fill(arr,1,3,8);             for(int i=0;i<arr.length;i++)                 System.out.println("第"+(i+1)+"个元素是："+arr[i]);
    }}
2.对数组进行排序Arrays.sort(object)object：指进行排序的数组名称package com.company;import java.util.Arrays;public class Main {    public static void main(String[] args) {           int arr[]=new int[]{23,42,12,8,5,10};           for (int i=0;i<arr.length;i++){               System.out.print(arr[i]+" ");           }           Arrays.sort(arr);           System.out.println("\n升序排列后的数组是：");           for(int i=0;i<arr.length;i++) {               System.out.print(arr[i] + " ");           }    }}23 42 12 8 5 10 升序排列后的数组是：5 8 10 12 23 42 
3.复制数组copyOf()方法是复制数组指定长度，copyOfRange()方法则指定数组的指定长度复制到一个新数组中
（1）copyOf()方法copyOf(arr,int newlength)arr:要进行复制的数组newlength:int 型变量，指复制后的新数组的长度。如果新数组的长度大于数组arr的长度，则用0填充（整形数组用0填充，char型数组则会使用null来填充），如果复制后的数组长度小于数组arr的长度，则会从数组arr的一个元素开始截取至满足新数组长度为止package com.company;import java.util.Arrays;public class Main {    public static void main(String[] args) {    int arr[]=new int[]{23,42,12};    System.out.println("复制后后的数组是：");    for(int i=0;i<arr.length;i++){        System.out.print(arr[i]+" ");    }    int newarr[]=Arrays.copyOf(arr,5);    System.out.println("\n复制后的数组是：");    for(int i=0;i<newarr.length;i++){        System.out.print(newarr[i]+" ");    }    }}复制后后的数组是：23 42 12 复制后的数组是：23 42 12 0 0 
（2）copyOfRange()方法copyOfRange(arr,int formIndex,int toIndex)arr:要进行复制的数组对象formIndex:指定开始复制数组的索引位置，formIndex必须在0至整个数组的长度之间。新数组包括索引是formIndex的元素toIndex:要复制范围的最后索引位置。可以大于数组arr的长度，新数组不包括索引是toIndex的元素
package com.company;import java.util.Arrays;public class Main {    public static void main(String[] args) {      int arr[]=new int[]{23,42,12,84,10};      System.out.println("原来的数组是：");      for(int i=0;i<arr.length;i++){       System.out.print(arr[i]+" ");      }      int newarr[]=Arrays.copyOfRange(arr,0,3);      System.out.println("\n将数组下标0-3复制到新数组中：");      for(int i=0;i<newarr.length;i++)          System.out.print(newarr[i]+" ");    }}原来的数组是：23 42 12 84 10 将数组下标0-3复制到新数组中：23 42 12 
4.排序package com.company;import java.util.Arrays;public class Main {    public static void main(String[] args) {       int array[]=new int[]{63,4,253,1,23};        for(int i=1;i<array.length;i++){//冒泡排序            for(int j=0;j<array.length-i;j++){                if(array[j]>array[j+1]){                    int t=array[j];                    array[j]=array[j+1];                    array[j+1]=t;
                }
            }
        }        for(int i=0;i<array.length;i++)            System.out.print(array[i]+" ");    }}

package com.company;import java.util.Arrays;public class Main {    public static void main(String[] args) {     int array[]=new int[]{20,40,90,30,80,70,50};        System.out.println("排序前：");        for(int i=0;i<array.length;i++){            System.out.print(array[i]+" ");        }            int t,j;        for(int i=1;i<array.length;i++){            t=array[i];            for(j=i-1;j>=0&&array[j]>t;j--){                array[j+1]=array[j];
            }            array[j+1]=t;        }        System.out.println("\n排序后：");        for(int i=0;i<array.length;i++){            System.out.print(array[i]+" ");        }    }}