数组知识补充(2022.3.22)

一、 数组操作与数组封装类Arrays

1. 数组元素拷贝:System.arraycopy

   //方法原型
   public static native void arraycopy(Objet src,int srcPos,Object dest,int destPos,int length);

   native关键字告诉编译器(JVM)调用的该方法在外部定义

   作用是从src数组的srcPos位置往dest数组的destPos位置拷贝length个元素，

   注意，数组拷贝位置或元素数量不对时，可能出现ArrayTndexOutOfBoundException异常；

   类型不匹配时，，会出现ArrayStoreExcaption。示例：

   //有点问题
   import java.util.Arrays;//导入包
   public class Example56_1{
       public static void main(String[] args){
           int []a=new int[10];
           int []b={1,2,3,4,5};
           System.out.println("copy all elements of b[5] to a[10]:");
           System.arraycopy(b,0,a,0,b.length);
           //从b[0]开始，拷贝b.length个元素，然后a[0]位置开始粘贴
           System.out.println(Arrays.toString(a));//Arrays.toString(a)？
           
           System.out.println("copy 4 elements of a[10] "+
               "from index 0 to index 4:");
           System.arraycopy(a,0,a,4,4);
           System.out.println(Arrays.toString(a));//toString()不能理解。。
           
           System.out.println("copy 3 elements of a[10] "+
               "from index 0 to index 8:");
           System.arraycopy(a,0,a,8,3);
           System.out.println(Arrays.toString(a));
       }
   }

   错误：因为Arrays是外部的，要导入包 ：import java.util.Arrays;

   正确：

   toString()不能理解

2. 判断数组内容相等:Arrays.equals

   //Arrays中针对不同类型的数组提供了equals()方法的多个重载版本，包括各种基本类型的比较：
   public static boolean equals(int[] a,int[] a2);
   public Static boolean equals(long[] a.long[] a2);
   public Static boolean equals(boolean[] a.boolean[] a2);
   //...   以及对象组之间的比较:
   public static boolean equals(Object[] a,Object[] a2);

   示例：

   //有点问题
   import java.util.Arrays;
   public class Example56_2{
       public static void main(String[] args){
           int []a={1,2,3,4};
           int []b={1,2,3,4};
           System.out.println("int array compare equal?"+Arrays.equals(a,b));
           
           Integer c[]={new Integer(1),new Integer(3)};
           //Intege是int的封装类...不能理解。
           Integer d[]={new Integer(1),new Integer(3)};
           System.out.println("Integer array compare equal?"+Arrays.equals(c,d));
           
           Integer []e={1,3};//auto boxing;
           Integer []f={new Integer(1),new Integer(3)};
           System.out.println("Integer arry of autoBoxing and common Integer array:"+
               Arrays.equals(e,f));
           
           /* int g[]={1,3};
           Integer h[]={new Integer(1),new Integer(3)};
           System.out.println(Arrays.equals(h,g));//compile error */
       }
   }

   正确： Integer那不能理解

1. Arrays.fill:数组填充

   //方法原型
   public dtatic void fill(Object[] a,Object val);
   //此方法将val填充至数组a中的每一个位置。此处赋值是浅拷贝

   示例：

     //有点问题
      import java.util.Arrays;
      public class Example57_3{
       public static void main(String[] args){
           String strings[]=new String[10];//这个意思是？
           Arrays.fill(strings,"A");
           System.out.println(Arrays.toString(strings));
       }
      }

   正确：

   String strings[]=new String[10];什么鬼？

2. Arrays.asList:将数组转换为List

   //方法原型
   public static<T>List<T>asList(T...a);
   //此方法使用泛型作为参数及返回值，因此当方法参数和返回值List参数类型不一致时，编译器会报错

   示例：

   //有点问题
   import java.util.Arrays;
   public class Example57_4{
       public static void main(String[] args){
           String strings[]=new String[10];
           Arrays.fill(strings,"A");
           List<String>asList=Arrays.asList(strings);
           System.out.println(asList);
           int integers[]={1,2};
           List<Integer>integers1=Arrays.asList(integers);//编译出错
       }
   }

   错误：

   不太明白错误

3. Arrays.sort:数组排序

   //方法原型
   public static void sort(T[]a)
   //sort方法对于不同类型提供了多个重载版本

   示例：

   import java.util.Arrays;
   public class Example57_5{
       public static void main(String[] args){
           int []a={2,3,1,5,4};
           Arrays.sort(a);
           System.out.println(Arrays.toString(a));
       }
   }

   正确：

二、引用类型作方法参数（地址传递）

• 按值调用：方法接受的是调用者提供的值；

• 按引用调用：方法接受的是调用者提供的变量地址；

• 一个方法可以修改传递引用所对应的变量值；而不能修改传递值调用所对应的变量值；

• 方法参数有两种类型：基础数据类型和对象引用；