java数组总结

数组

相同数据类型的集合并且内存是连续的、
*1、定义一个一维数组：

int []arr={1,2,3,4,5};//静态初始化
int []arr2=new int[]{1,3,4,5,6};
int []arr3=new int[5]    //new 产生一个对象，动态初始化
 ”引用“用来存放对象的地址；

java在声明一个数组时是如何分配内存的?初始化方式有几种？
java有两种初始化方式，静态和动态初始化。区别是有系统指定长度还是由程序员指定长度。然后系统根据指定长度在堆内存中寻找大小符合的连续的内存块分配给数组，并根据数组类型初始化每个元素的值，初始化完成后，数组长度不可变哦！
2、数组长度：数组名.length(是数组的属性)
3、数组越界：（运行）异常：java.lang.ArrayIndexOutOfBoundsException
4、遍历数组*：

for循环；for (int i = 0; i < arr2.length; i++){
             System.out.println(arr2[i]);
			}
foreach循环:for (int x:arr2) {//不能通过下标访问数组
                System.out.print(x+" ");
			   }
(数组定义好后没有初始化，结果全为零)
//数组当中如果是引用类型就是null
for和foreach循环的区别：foreach不能用下标去访问数组元素

Java中到底是传地址还是传值？传值，因为地址也是值
5、 参数传内置类型：**

  public static void main(String[] args) {    
	      int num = 0;    
		  func(num);    
		  System.out.println("num = " + num); 
		  }

	 public static void func(int x) {    
	     x = 10;   
		 System.out.println("x = " + x); 
		}
// 执行结果 x = 10 num = 0 
修改形参 x 的值, 不影响实参的 num 的值

6、 参数传数组类型:

 public static void main(String[] args) {    
	     int[] arr = {1, 2, 3};     
	     func(arr);     
	     System.out.println("arr[0] = " + arr[0]); 
	 } 
     public static void func(int[] a) {     
	     a[0] = 10;     
		 System.out.println("a[0] = " + a[0]); } 
 
// 执行结果 a[0] = 10 arr[0] = 10 

在函数内部修改数组内容, 函数外部也发生改变. 此时数组名 arr 是一个 “引用” . 当传参的时候, 是按照引用传参
所谓的 “引用” 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参,
其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大)
***7、JVM：虚拟机，它的内存区域划分：***
(1、jvm虚拟机栈：存储局部变量
(2、本地方法栈：native方法：底层是由C/C++实现
(3、程序计数器： 保存下一条执行的指令的地址
(4、堆（Heap）：对象、JVM所管理的大内存区域. 使用 new 创建的对象都是在堆上保存
(5、方法区：静态变量、类信息
(6、常量池：在JDK1.7前，常量池在方法区，1.7及其以后，被移到了堆中；
***8、

int []arr2={1,2,3,4};
 System.out.print(arr2); //输出：[I@1540e19d ——》代表地址哈希码***

9、null是所有引用类型的初始值

int []arr=null;
   System.out.print(arr.length);
   String str=null;
   System.out.print(str.length());
会产生空指针异常：java.lang.NullPointerException

10、将数组以字符串形式输出：
（1、直接调用arrays方法：import java.util.Arrays;
int []arr={12,2,3,4,5};
System.out.print(Arrays.toString(arr));
11、copy数组

(1、for循环
(2、System.arraycopy(array,0,array2,0,array.length)(最快，调用底层方法)
(3、array2=Arrays.copyOf(array,array,length)
(4、array2=array.clone();

(5、浅拷贝：对引用类型的拷贝
(6、深拷贝：对传值类型的拷贝//copyOf是对数组进行了深拷贝，即创建了一个新的数组对象，
拷贝原有数组的所有元素到新的数组中，因此修改原数组，不会影响新数组。
如果两个引用，同时指向一个对象，那麽通过一个引用修改当前对象的值后，那么另一个引用也会受到影响，这就是浅拷贝
12、二维数组：
不规则：

int [][]array4=new int [3][];
array4[0]=new int[2];
array4[1]=new int[3];
array4[2]=new int[4];

int array5={{1},{3,4},{5,6}}

规则de:

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

注意：int [][]arr1={{1,3},{4,5},{7,8,9}};用for循环打印会发生数组越界
打印二维数组：for循环
deepToString(array);
13、***//Arrays工具类的使用***

 ** Arrays.copyOfRange拷贝部分
 * Arrays.equals(array,array2)
 *Arrays.fill(array,9); 全部填充为9
 * Arrays.fill(array,2,7,9);2号下标到7号下标填充为9
 * 不包含7号下标
 * Arrays.sort(array2);对数组进行排序
 *Arrays.sort底层是什么排序？》》快速排序
 * Arrays.toString();//打印一维数组
 * Arrays.deepToString();//打印二维数组*  

    public static void main(String[] args) {
        int[] array = new int[10];
        System.out.println(Arrays.toString(array));
        Arrays.fill(array,2,7,9);
        System.out.println(Arrays.toString(array));
        int[] array2 = {19,8,5,1,9,11,16};
        System.out.println(Arrays.toString(array2));
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
    }

java数组的操作的方法

 /*
    求数组最大值
     */
    public static int max(int []arr) {
        int maxv=arr[0];
        for(int i=0;i<arr.length;i++) {

            if(arr[i]>maxv) {
                maxv=arr[i];
            }
        }
        return maxv;
    }
    /*
    求最小值
     */
    public static int min(int []arr) {
        int minn=arr[0];
        for(int i=0;i<arr.length;i++) {

            if(arr[i]<minn) {
                minn=arr[i];
            }
        }
        return minn;
    }
    /*
    求平均数
     */
    public static double ave(int []arr) {
        int sum=0;
        for (int i = 0; i <arr.length ; i++) {
            sum=sum+arr[i];
        }
        return (double)sum / (double)arr.length;
    }
    /*
    逆置
     */
    public static void reverse(int []arr) {
        int left=0;
        int right=arr.length-1;
        while(left<right) {
            int temp=arr[left];
            arr[left]=arr[right];
            arr[right]=temp;
            left++;
            right--;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
    /*
    奇数放前，偶数放后
     */
    public static void fun3(int []arr) {
        int left = 0;
        int right = arr.length-1;
        while (left < right) {
            while (arr[left] % 2 == 1 && left < right) {
                left++;
            }
            while (arr[right] % 2 == 0 && left < right) {
                right--;
            }
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
    /*
  数组转字符串
  */
    public static String tostring(int[] array) {
        String ret = "[";
        for (int i = 0; i < array.length; i++) {
            ret = ret + array[i];
            if (i != array.length - 1) {
                ret = ret + ",";
            }
        }
        ret = ret + "]";
        return ret;
    }
/*
调用Arrays方法数组转字符串输出
 */
    public static void main1(String[] args) {
        int []arr={12,2,3,4,5};
        System.out.print(Arrays.toString(arr));

    }
    /*
    数组所有元素乘2
     */
    public static int []fun2(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i] * 2;
        }
        return ret;
    }
    public static void fun(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] * 2 + " ");
        }
    }
  

自定义数组的排序

public class Student implements Comparable<Student> {
    public String name;
    public int score;
    public static int flag;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return name + " " + score;
    }

    @Override
    public int compareTo(Student o) {
        if (flag==0) {
            return o.score-score;
        }
        return score - o.score;
    }

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while (sc.hasNext()) {
            int n=sc.nextInt();
            Student.flag=sc.nextInt();

            Student[] students=new Student[n];
            for (int i = 0; i < n; i++) {
                students[i]=new Student(sc.next(),sc.nextInt());
            }

            Arrays.sort(students);
            for (Student i:students
                 ) {
                System.out.println(i);
            }
        }

    }
}