目录
1.数组基本用法
1.1 什么是数组
数组就是相同数据类型的集合。
注意事项: 在 Java 中, 数组中包含的变量必须是 相同类型
1.2 创建数组
public static void main2(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7};//静态初始化
int[] array2 = new int[3];//动态初始化,默认值0
int[] array3 = new int[]{1, 2, 3, 4, 5};
}
数组定义不能指明其大小。
1.3 数组的使用
public static void main3(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7};
// System.out.println(array.length);//7
System.out.println(array[3]);//4
array[3] = 19;
System.out.println(array[3]);//19
}
注意事项
- 使用 arr.length 能够获取到数组的长度. . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
- 使用 [ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
- 使用 [ ] 操作既能读取数据, 也能修改数据.
- 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常
遍历数组:for循环,for each,还有就是Arrays.toString(数组名)
public static void main4(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6};
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
for (int x : array) {//增强for循环
System.out.print(x + " ");
}
System.out.println();
//借助Arrays的toString()方法,返回值是String
String ret = Arrays.toString(array);
System.out.println(ret);
System.out.println(Arrays.toString(array));
}
2. 数组作为方法的参数
2.1 基本用法
打印数组内容
public static void printf(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
public static void main6(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6};
printf(array);//按引用传递,或者按值传递
}
2.2 理解引用类型(重点/难点)
public static void func1(int[] array) {
array = new int[]{11, 2, 13, 4, 51, 61};
}
public static void func2(int[] array) {
array[0] = 899;
}
public static void main7(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6};
System.out.println(Arrays.toString(array));
func1(array);
System.out.println(Arrays.toString(array));//1,2,3,4,5,6
func2(array);
System.out.println(Arrays.toString(array));//899,2,3,4,5,6
}
总结: 所谓的 “引用” 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).
2.3 认识 null
null 在 Java 中表示 “空引用” , 也就是一个无效的引用
int[] arr = null;
System.out.println(arr[0]);
// 执行结果 Exception in thread "main" java.lang.NullPointerException at Test.main(Test.java:6)
2.4 初识 JVM 内存区域划分(重点)
局部变量和引用保存在栈上, new 出的对象保存在堆上.
堆的空间非常大, 栈的空间比较小.
堆是整个 JVM 共享一个, 而栈每个线程具有一份(一个 Java 程序中可能存在多个栈)
3. 数组作为方法的返回值
将数组作为方法返回值,将数组元素扩大到原来的2倍
public static int[] transform(int[] array) {
int[] ret = new int[array.length];
for (int i = 0; i < array.length; i++) {
ret[i] = 2 * array[i];
}
return ret;
}
public static void main10(String[] args) {
int[] array = {1, 2, 3, 4, 5};
//func(array);
int[] ret = transform(array);
System.out.println(Arrays.toString(ret));
}
4. 数组练习
4.1 数组转字符串
前面数组转为字符串可以用Java 中提供了 java.util.Arrays 包
, 其中包含了一些操作数组的常用方法。
下面我自己定义一个方法myToString
public static String myToString(int[] arr) {
String str = "[";
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1) {
str = str + arr[i] + ',';
} else {
str = str + arr[i] + ']';
}
}
return str;
}//[1,2,3,4,5]
public static void main11(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
System.out.println(myToString(arr));
}
4.2 找数组中的最大元素
将数组第一个元素初始化为最大值max,从第二个元素比较,如果有比max更大的,就将max更新。
private static int maxNum(int[] array) {
if (array == null)
return -1;
if (array.length == 0)
return -1;
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max)
max = array[i];
}
return max;
}
public static void main12(String[] args) {
int[] array = {12, 8, 1, 2, 10};
System.out.println(maxNum(array));
}
4.3查找数组中指定元素(顺序查找)
public static void main13(String[] args) {
int[] arr = {12, 3, 67, 88, 45};
System.out.println(findNum(arr, 88));
}
private static int findNum(int[] arr, int key) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == key)
return i;
}
return -1;
}
4.6 查找数组中指定元素(二分查找)
针对有序数组, 可以使用更高效的二分查找.
public static int binarySearch(int[] arr, int key) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (key < arr[mid]) { // 去左侧区间找
right = mid - 1;
} else if
(key > arr[mid]) {
// 去右侧区间找
left = mid + 1;
} else { // 相等, 说明找到了
return mid;
}
}
// 循环结束, 说明没找到
return -1;
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 15, 17};
System.out.println(binarySearch(arr, 15));
}
4.7 检查数组的有序性(升序)
是有序返回true,否则返回false
public static boolean isUp(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
if (arr[i] > arr[i + 1]) {
return false;
}
}
return true;
}
public static void main(String[] args) {
int[] arr={34,56,78,23,90,76};
System.out.println(isUp(arr));
}
4.8 数组排序(冒泡排序)
public static void bubbleSort(int[] arr) {
for (int i = 1; i <arr.length ; i++) {
boolean flg=false;
for (int j = 0; j < arr.length-i; j++) {
if(arr[j]>arr[j+1]){
int tmp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=tmp;
flg=true;
}
}
if(flg==false){
break;
//return;
}
}
}
public static void main(String[] args) {
int[] arr = {11, 34,78, 15};
/*boolean flg = isUp(arr);
System.out.println(flg);*/
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
冒泡排序性能较低. Java 中内置了更高效的排序算法Arrays.sort(arr);
**Arrays.sort(arr)**将数据从小到大排列
public static void main(String[] args) {
int[] arr = {11, 34,78, 15};
/*boolean flg = isUp(arr);
System.out.println(flg);*/
//bubbleSort(arr);
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
4.9 数组逆序
设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
然后让前一个下标自增, 后一个下标自减, 循环继续即可.
private static void reverse(int[] arr) {
int left=0;
int right=arr.length-1;
while(left<=right){
int tmp=arr[left];
arr[left]=arr[right];
arr[right]=tmp;
left++;
right--;
}
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
4.10 数组数字排列
给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分
思路:设定两个下标分别指向第一个元素和最后一个元素.用前一个下标从左往右找到第一个奇数, 用后一个下标从右往左找到第一个偶数, 然后交换两个位置的元素.依次循环即可。
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
transform(arr);
System.out.println(Arrays.toString(arr));
}
public static void transform(int[] arr) {
int left = 0;
int right = arr.length - 1;
while (left < right) {
// 该循环结束, left 就指向了一个奇数
while (left < right && arr[left] % 2 == 0) {
left++;
}// 该循环结束, right 就指向了一个偶数
while (left < right && arr[right] % 2 != 0) {
right--;
}// 交换两个位置的元素
int tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
}
}
4.10 数组的拷贝
1.
public static int[] copyArr(int[] arr) {
int[] copy = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
copy[i] = arr[i];
}
return copy;
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
int[] ret = copyArr(arr);
System.out.println(Arrays.toString(ret));
}
****2.Arrays.copyOf(,)方法
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
int[] ret = Arrays.copyOf(arr, arr.length);
System.out.println(Arrays.toString(ret));
}
局部拷贝:
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
// int[] ret = Arrays.copyOf(arr, arr.length);
int[] ret = Arrays.copyOfRange(arr, 0, 4);
System.out.println(Arrays.toString(ret));
}
3.System.arraycopy()方法
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
int[] copy = new int[arr.length];
System.arraycopy(arr, 0, copy, 0, arr.length);
// int[] ret = Arrays.copyOf(arr, arr.length);
// int[] ret = Arrays.copyOfRange(arr, 0, 4);
System.out.println(Arrays.toString(copy));
}
4.产生对象副本clone()
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
int[] copy=arr.clone();
System.out.println(Arrays.toString(copy));
}
深拷贝是拷贝对象,不对对象做拷贝,只是拷贝地址,前面都是浅拷贝
需要看拷贝的是什么,才能决定是深拷贝还是浅拷贝
5. 二维数组
二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据};
二维数组的3种打印方式:
public static void main(String[] args) {
int[][] arr = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};//[][]中不能加数字
//int[][] arr2 = new int[][]{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
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();
}
System.out.println("==================");
for (int[] ret : arr) {
for (int x : ret) {
System.out.print(x + " ");
}
System.out.println();
}
System.out.println("===================");
System.out.println(Arrays.deepToString(arr));
}
数组的应用:
public static void main2(String[] args) {
int[][] arr = {{1, 2}, {4, 5, 6}};//[][]中不能加数字
/*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();
}*/
/* System.out.println("==================");
int[][] arr2=new int[2][];
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2[i].length; j++) {
System.out.print(arr2[i][j] + " ");
}
System.out.println();
}*/
int[][] arr2 = new int[2][];
arr2[0]=new int[3];
arr2[1]=new int[2];
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2[i].length; j++) {
System.out.print(arr2[i][j] + " ");
}
System.out.println();
}
}