java返回值 shell java返回值类型是什么意思

一、Arrays

jdk中为了便于开发，给开发者提供了Arrays类，其中包含了很多数组的常用操作。例如快速输出、排序、查找等。

1.数组的常用方法

1.数组以字符串形式的输出，2.sort对数组排序(只能升序)，3.填充数组（填充同一个值），4.equals(arr1,arr2) 判断两个数组是否相等。

import

2.二分法查找

二分法查找必须是有序的数组，如果找到返回索引；如果没有找到，返回-插入点-1。插入点就是key应该放到数组的位置。

private static int binarySearch0(long[] a, int fromIndex, int toIndex,
                                     long key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            long midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

二分法查找的形象图：

3.数组的复制

copyOf(arr,len) 把arr复制len个长度的元素并返回新数组。如果len>arr.length,新数组的长度末尾用0填充。

copyOfRange(arr,from,to) 从arr中from(包含)位置开始复制到to(不包含)这个范围的元素到新数组中。含头不含尾。

import java.util.Arrays;
public class Text1{
	public static void main(String[] args){
		
		int[] arr = {1,2,4,6,7,9};
		//copyOf(arr,len) 
	        int[] arr2 = Arrays.copyOf(arr,5);//复制整体
	        System.out.println(Arrays.toString(arr2));
		
		// copyOfRange(arr,from,to)
		int[] arr3 = Arrays.copyOfRange(arr,2,7);//复制某一段
	        System.out.println(Arrays.toString(arr3));
	}
}

输出是：

其中System也提供了赋值数组的方法。

arraycopy(srcArr,srcPos,destArr,destPos,len)

srcArr:要复制的源数组

srcPos:从srcArr的srcPos位置开始复制

destArr:复制到的目标数组

destPos:目标数组从destPos开始存放

len:从源数组中复制len个长度

int[] arr4 = new int[arr.length];
	System.arraycopy(arr,2,arr4,1,4);
	System.out.println(Arrays.toString(arr4));

输出是：

二、二维数组

1.二维数组基础

二维数组就是数组的数组，数组的元素也是数组。

二维数组表示行列二维结构。

2.二维数组的声明

import java.util.Arrays;
public class Test05{
	public static void main(String[] args){
		
		// 二维数组
		//int[]
		// (int[]) []
		
		
		// 【1】声明
		int[][] arr;
		// 【2】初始化一个能存3个一维数组的二维数组
		arr = new int[3][];
		
		// 【3】赋值
		int[] arr1 = {1,3,4,5};
		int[] arr2 = {1,3,4};
		int[] arr3 = {2,1,6,4};
		
		arr[0] = arr1;
		arr[1] = arr2;
		arr[2] = arr3;
		
		System.out.println(arr);
		System.out.println(Arrays.toString(arr));
	}
}

但是此时中的arr = new int[3][]; 只分配了二维数组的空间，一维数组没有分配空间。

声明一个规则的二维数组：

import java.util.Arrays;
public class Test06{
	public static void main(String[] args){
		
		// 声明一个规则的二维数组，3行4列
		int[][] arr;
		arr = new int[3][4];
		
		arr[0][0] = 10;
		arr[0][1] = 20;
		arr[0][2] = 30;
		arr[0][3] = 40;
		
		arr[1][0] = 100;
		arr[1][1] = 200;
		arr[1][2] = 300;
		arr[1][3] = 400;
		
		arr[2][0] = 1000;
		arr[2][1] = 2000;
		arr[2][2] = 3000;
		arr[2][3] = 4000;
		
		System.out.println(Arrays.toString(arr));
	}
}

此时，二维数组已经分配好空间，同时一维也分配好空间。但代码量多，麻烦。

当已知二维数组的值数，可以考虑字面量声明

import java.util.Arrays;
public class Test07{
	public static void main(String[] args){
		
		// 声明字面量二维数组
		int[][] arr = {
			{10,20,30,40},
			{100,200,300},
			{1000,2000,3000,4000}
		};
		System.out.println(Arrays.toString(arr));
	}
}

3.二维数组的遍历

import java.util.Arrays;
public class Text2{
	public static void main(String[] args){
   int[][] arr = {
	   {1,2,3,4},
	   {5,6,7,8},
	   {9,10}
   };
   for(int i = 0;i<arr.length;i++){
	   for(int j = 0;j<arr[i].length;j++){
		 System.out.print((arr[i][j])+" ");  
	   }System.out.println();  
   }
   
   
	
	}

}

输出是：

总结：

二维数组是行列结构，使用双层for循环，外层for用于控制行，内层for用于控制列

=> 行列结构 => 双层for遍历。

三、 基本数据类型和引用数据类型赋值的区别

import java.util.Arrays;
public class Test09{
	public static void main(String[] args){
		
		// 基本数据类型的赋值
		int a = 10;
		int b;
		b = a;
		// a=10,b=10
		b = 20;
		// a=10,b=20
		
		// 引用数据类型的赋值
		int[] arr = {1,3,5};
		int[] arr2 = arr;
		arr2[0] = 100;
		
		System.out.println("arr:"+arr);// {100,3,5}
		System.out.println("arr2:"+arr2);//{100,3,5}
		
		System.out.println("arr[0]:"+arr[0]);//arr[0]=100
		
	}
}