Java基础03

获取时间

获取当前时间距离 1970-1-1 零时的毫秒数

long msTime = System.currentTimeMillis();

break和continue

	使用范围	区别
break	switch-case、循环结构	结束当前（最近的）循环
continue	循环结构	结束当次循环

• 两者后面均不能声明执行语句
• 默认结束最近的一层循环，可通过添加标识来结束指定的某一层循环

label:for(......){
for(...){
      ...
      break label;  //结束外层循环     
}
}

数组

数组（Array）：是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

数组的特点

• 数组是有序的。
• 数组本身属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。
• 创建数组对象会在内存中开辟一整块连续的空间。
• 数组的长度一旦确定就不能修改。

数组的分类

1. 按照维数：一维数组、二维数组
2. 按照数组元素类型：基本数据类型元素的数组、引用数据类型元素的数组。

一维数组

1. 声明和初始化

   int[] ids;  //声明
   ids = new int[]{1001,1002,1003,1004};   //静态初始化:数组初始化及元素赋值同时进行
   int[] arr1 = new int[]{1,2,3,4,5};   //此处new int[]可省略
   String[] names = new String[5];   //动态初始化：数组初始化及元素赋值分开操作
   

2. 调用数组的指定位置的元素（通过角标/下标/索引）

   //角标从0开始，到数组长度-1结束 
   names[0] = "张三";
   names[1] = "李四";
   names[2] = "王五";
   

3. 获取数组的长度

   System.out.print(names.length);  //输出结果为5
   

4. 遍历数组

   for(int i =0;i < names.length;i ++){
       System.out.print(names[i]);
   }
   

5. 数组元素的默认初始化值

   • 数组元素是整形：0
   • 数组元素是浮点型：0.0
   • 数组元素是char型：0/’\u0000’，而非’0’
   • 数组元素是boolean型：false
   • 数组元素是引用数据类型/String：null

   ---

二维数组

对于二维数组，可以看成是一维数组array1又作为另一个一维数组array2的元素二存在。

1. 声明和初始化

   int[][] ids;  //声明
   ids = new int[][]{{1,2,3},{4,5},{6,7,8}};   //静态初始化:数组初始化及元素赋值同时进行
   String[][] names = new String[3][2];   //动态初始化：数组初始化及元素赋值分开操作
   String[][] names = new String[3][];
   names[1] = new String[4]; 
   

2. 调用数组的指定位置的元素（通过角标/下标/索引）

   int[][] ids = new int[][]{{1,2,3},{4,5},{6,7,8}};
   System.out.println(ids[0][1]);   //输出2
   

3. 获取数组的长度

   System.out.println(ids.length);   //输出结果为3
   System.out.println(ids[0].length);   //输出结果为3
   System.out.println(ids[1].length);   //输出结果为2
   

4. 遍历数组

   int[][] ids;  //声明
   ids = new int[][]{{1,2,3},{4,5},{6,7,8}};   //静态初始化:数组初始化及元素赋值同时进行
   for(int i =0;i < ids.length;i ++){
       for(int j = 0;j < ids[i].length;j++) {
           System.out.print(ids[i][j] + " ");
       }
       System.out.println();
   }
   

5. 数组元素的默认初始化值

   对于初始化方式为：int[][] arr = new int[4][3];
   外层元素为：地址值；      内层元素与一维数组初始化相同
   
   对于初始化方式为：int[][] arr = new int[4][];
   外层元素为：null；        内层元素无法调用，否则报错
   

   ---

数组的一些操作

1.数组的复制

int[] arr1,arr2;
arr1 = new int[]{1,2,3,4,5};
arr2 = arr1;    //此时两者地址值相同，都指向了堆空间的唯一的一个数组实体，不能称作数组的复制
                //此时更改arr2，arra1也会随之更改
//数组的复制
int[] arr2 = new int[arr1.length]
    for(int i = 0;i < arr2.length;i ++){
        arr2[i] = arr1[i];
    }

2.数组的反转

for(int i =0;i < arr.length / 2;i ++){
    String temp = arr[i];
    arr[i] = arr[arr.length - 1 - i];
    arr[arr.length - 1 - i] = temp;
}

3.数组的查找

3.1线性查找

String dest = "AA";
boolean isFlag = false;
for(int i = 0;i < arr.length;i ++){
    if(dest.equals(arr[i])){
        isFlag = true;
        break;
    }
}
System.out.print(isFlag ? "yes" : "no");

3.2二分法查找

前提：所要查找的数组必须要有序。

int[] arr = new int[]{-6,-4,-2,0,1,3,5}; 
		int value = 1;
		boolean isFlag = false;
		int middle = 0;
		
		int head = 0;
		int end = arr.length - 1;		
		
		while(head <= end) {
			middle = (head + end) / 2;
			
			if(arr[middle] == value) {
				isFlag = true;
				break;
			}else if(arr[middle] > value) {
				end = middle - 1;
			}else {
				head = middle + 1;
			}
		}
		
		System.out.println((isFlag ? "索引位置在:" + middle : "不存在"));

4.数组的排序

4.1冒泡排序

int[] arr = new int[] {49,38,65,97,76,13,27,49};
		
		for(int i = 0;i < arr.length - 1;i ++) {
			for(int j = 0;j < arr.length - 1 - i;j ++) {	
				if(arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
for(int i = 0;i < arr.length;i ++) {
			System.out.print(arr[i] + " ");
		}

Arrays常用工具类

//1.判断两个数组是否相等   boolean equals(int[] a,int[] b)
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1,arr2);

//2.输出数组信息   String toString(int[] a)
System.out.print(Arrays.toString(arr1));  //输出结果: [1,2,3,4]

//3.将数组中所有值统一替换成指定的一个值   void fill(int[]a,int val)
Arrays.fill(arr1,5);
System.out.print(Arrays.toString(arr1));  //输出结果：[5,5,5,5]

//4.快速排序（升序）   void sort(int[] a)
Arrays.sort(arr2);
System.out.print(Arrays.toString(arr2));  //输出结果：[1,2,3,4]

//5.查找指定值索引   int binarySearch(int[] a,int key)
int index = Arrays.binarySearch(arr1,3);  //若未找到则输出负数

​