数组
数组声明和创建
package com.cwk.array;
public class Demo01 {
public static void main(String[] args) {
//数组: 引用数据类型 开辟一组空间存放相同类型的数 int[]只能存int double[]存double，创建时长度要确定，不可更改，下标从零开始
//声明数组(nums在栈中为变量名,存放这个引用在堆中的具体地址) 创建数组，确定长度，在堆创建了10个int类型的空间,全部默认为0
int[] nums=new int[10];
//对数组每个元素赋值
for (int i = 0; i < nums.length; i++) {
nums[i]=i;
}
//遍历数组
for (int num : nums) {
System.out.println(num);
}
}
}
内存分析
![无标题]()
![image-20210413113831526]()
package com.cwk.array;
public class Demo02 {
public static void main(String[] args) {
//数组内存分析和三种初始化
//int[5] a;非法的 声明时没有实例化任何对象，实例化数组对象，jvm才会分配空间，才会有长度，因此，声明数组时不能指定其长度(数组中元素的个数）
//声明一个数组
int[] a=null;
System.out.println(a);
//创建数组 a指向这个数组在堆中首地址
a=new int[5];
System.out.println(a);
//三种初始化
//静态初始化 声明数组，创建数组，分配空间，赋值
int[] nums={1,2,3};
//动态初始化 声明数组，创建数组,为数组元素分配空间、赋值的操作、分开进行。
int[] nums1=new int[2];
nums1[0]=1;
nums1[1]=2;
//默认初始化 数组引用类型，元素相当于类的实例变量，数组对象被建立，实例变量也被默认初始化
int[] num2=new int[2];
for (int i : num2) {
// 输出0 boolean[] 为false String[] 为null
System.out.println(i);
}
}
}
一维数组注意点和总结
package com.cwk.array;
public class Demo03 {
public static void main(String[] args) {
//数组注意点与总结
//数组下标[0-length-1]
// 数组是相同数据类型(数据类型可以为任意类型)的有序集合
// 数组也是对象。数组元素相当于对象的成员变量(详情请见内存图)
// 数组长度的确定的，不可变的。如果越界，则报：ArrayIndexOutofBounds
}
}
数组的使用
package com.cwk.array;
public class Demo04 {
public static void main(String[] args) {
//数组的使用
int[] arrays=new int[5];
//普通for循环，可以修改数组元素的值
for (int i = 0; i < arrays.length; i++) {
arrays[i]=i;
}
//增强for循环
for (int array : arrays) {
System.out.println(array);
}
//数组作为参数
printMax(arrays);
//数组作为返回值
// System.out.println("-------------");
// int[] arrays2=reverse(arrays);
// //原数组被反转
// printArray(arrays2);
// printArray(arrays);
int[] array2=reverse2(arrays);
//原数组不被反转
printArray(array2);
printArray(arrays);
}
private static int[] reverse2(int[] arrays) {
//原数组不被反转，重新建立一个新数组，长度相同，不可以int[] result=arrays; result也指向了堆的那块数组空间
int[] result=new int[arrays.length];
for (int i = 0,j=result.length-1; i < result.length; i++,j--) {
result[i]=arrays[j];
}
return result;
}
private static void printArray(int[] arrays2) {
for (int i : arrays2) {
System.out.print(i+" ");
}
System.out.println();
}
private static int[] reverse(int[] arrays) {
//反转数组
// 原数组的值会被修改
for (int i = 0; i < arrays.length / 2; i++) {
int t=arrays[arrays.length-i-1];
arrays[arrays.length-i-1]=arrays[i];
arrays[i]=t;
}
return arrays;
}
//打印数组最大值
private static void printMax(int[] arrays) {
int result=arrays[0];
for (int array : arrays) {
if(array>result) {
result=array;
}
}
System.out.println(result);
}
}
二维数组
![数组]()
package com.cwk.array;
public class Demo05 {
public static void main(String[] args) {
//二维数组，
//创建两行三列的二维数组
int[][] nums=new int[2][3];
//第二种数组:一维数组的元素变成数组
int[][] arrays={{1,2},{3,4},{5,6}};
//遍历
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
System.out.print(arrays[i][j]+" ");
}
System.out.println();
}
}
}
Arrays工具类
package com.cwk.array;
import java.util.Arrays;
public class Demo06 {
public static void main(String[] args) {
//Arrays类 工具类
int[] arr = {1, 3, 2, 4, 35, 53, 13, 43};
System.out.println(Arrays.toString(arr));
// System.out.println(printArray(arr));
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//数组复制
int[] a={1,2,32,3,1,5};
//原数组，起始索引，终止索引（左边右开），返回一个新数组
int[] b = Arrays.copyOfRange(a, 0, a.length);
System.out.println(Arrays.toString(b));
// 数组复制方法二 要事先创立一个数组
int[] c=new int[a.length];
//原数组 源数组复制数据的起始位置 目标数组 复制到目标数组的启始位置 复制长度
System.arraycopy(a,0,c,0,a.length);
System.out.println(Arrays.toString(c));
}
//模拟toString,可以看源码
private static String printArray(int[] arr) {
if (null == arr) {
return null;
}
int iMax = arr.length - 1;
if (iMax == -1) {
return "[]";
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("[");
for (int i = 0; ; i++) {
stringBuilder.append(arr[i]);
if (iMax == i) {
return stringBuilder.append("]").toString();
}
stringBuilder.append(", ");
}
}
}
冒泡排序
package com.cwk.array;
import java.util.Arrays;
public class Demo07 {
public static void main(String[] args) {
int[] arr={1,3,2,35,3,2,5,7,4,90,50};
int[] arr1=bubbleSort(arr);
System.out.println(Arrays.toString(arr1));
}
private static int[] bubbleSort(int[] arr) {
//冒泡排序
//外部循环，决定走几趟，最复杂情况下arr.length-1次才可以排序后
int temp=0;
for (int i = 0; i < arr.length - 1; i++) {
//加个标志位，如果排序已经完成（没有交换了）即可退出
boolean flag=true;
for (int j = 0; j < arr.length - i - 1; j++) {
//把大的往后面移 从小到大排序
if(arr[j+1]<arr[j]){
temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
flag=false;
}
}
if(flag){
break;
}
}
return arr;
}
}
浙公网安备 33010602011771号