数组
数组:
用来存储同一类型多个元素的容器
数组长度固定
通过索引查找元素,索引下标从0开始
public class Ran {
public static void main(String[] args) {
// 数组的声明
// 数组类型[] 变量名 = new 数组类型[数组长度]
// 方式一 数组的动态初始化,只给出长度,系统提供默认的初始化
int[] i = new int[5];
// String[] str = {"a","b","c","d","e"};//方式二 静态初始化
// int [] i2 = new int[] {1,2,3,4};//方式三 静态初始化
//方式二最常用,但是这种方式不能作为返回值,return {1,2,3}
//数组的赋值与访问,数组有下标(索引),从0开始,依次递增
i[0] = 2;
i[1] = 5;
i[2] = 57; //利用索引赋值
i[3] = 7;
i[4] = 6;
//i[5]=70; 数组常见的异常——索引越界异常
System.out.println(i[2]);//57 //利用索引取单个值
//获取数组中所有的值:遍历
for(int index = 0 ;index < i.length ; index++) {
//length是数组的属性,表示数组的元素个数
System.out.println(i[index]);
}
//增强for遍历
for(int ret : i){
System.out.println(ret);
//没有索引,无法直接操作数组元素;但是减少了代码量,方便了数组的遍历
}
}
public static String[] add() {
return new String[]{"1"};
}
}
Java对内存分为5个区域:
寄存器:内存,CPU之间
本地方法区:JVM调用了系统中的功能
方法和数据共享区:运程序行期,class进入的地方
方法栈:所有方法运行时进入的内存
堆:存储容器和方法
简易流程
1.方法和数据共享区加载运行class文件
2.main方法进入栈内存运行
创建引用int[] i
3.在堆中创建容器存储
new int[5]
将堆中的内存地址赋值给栈的引用
System.out.println(i) 输出的就是引用中的内存地址,而不是数组中具体的元素
栈内存是先进后出
长度为0的数组并不是null
空数组的引用不指向任何对象
Java的内存分配:
A:栈 存储局部变量(方法中定义或声明的变量)
B:堆 存储所有new出来的
C:方法区(面向对象部分详细讲解)
D:本地方法区(系统相关)
E:寄存器(CPU使用)
二维数组
//二维数组
int [] [] i = new int[3][4];
//最简单的定义int [] [] i = { {1,2,3} , {4,5,6} , {7,8,9} }
//赋值
i[0][0] = 1;
i[0][1] = 2;
i[0][2] = 3;
i[1][0] = 3;
i[1][1] = 3;
i[1][2] = 3;
数组最值
public static void main(String[] args) {
//数组最值
int[] i = {1,5,2,5,4,7,6,9,87,54,67,35};
int max = i[0];
for(int index = 1; index < i.length ; index ++ ) {
if(i[index] > max) {
max = i[index];
}
}
System.out.println("数组中最大值为:" + max);
}
数组的冒泡排序
public static void main(String[] args) {
//数组的冒泡排序
int[] arr = {1,5,2,5,4,7,6,9,87,54,67,35};
for(int i = 0; i < arr.length ; i ++ ) {
boolean flag = false;
for(int j = 0; j < arr.length - 1 - i; j ++) {
if(arr[j] > arr[j+1] ) {
int f = arr[j];
arr[j] = arr[j+1];
arr[j+1] = f;
flag = true;
}
}
if (!flag){
//优化点:如果某一次排序后,元素没有发生交换,说明此事元素已经排序完毕,
//当前元素后面的元素就不需要在继续比较了
break;
}
}
数组的选择排序
int [] arr = {1,25,62,14,22,23,32,54,14};
//选择排序
for(int i = 0 ;i < arr.length - 1; i++ ) {
int min = i; //最小值下标为i
for(int j = i + 1 ; j < arr.length; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
if (min != i) { //减少交换次数
int temp = arr[i];
arr[i] = arr[min] ;
arr[min] = temp;
}
}
//遍历
for (int i : arr) {
System.out.print(i + " ");
}
冒泡排序与选择排序的区别:
冒泡排序是每次比较两个相邻元素大小;
选择排序是假设首位为最大/最小值去按顺序与后面的元素一一比较
冒牌排序每次比较后,位置不对都会交换位置
选择排序每次比较完后不会交换位置,只会在比较了一轮后才交换位置
数组元素反转
int [] i = {1,2,3,4,5,6,7,8,9};
for(int start = 0,end = i.length - 1; start < end; start++, end--) {
int temp = i[start];
i[start] = i[end];
i[end] = temp;
}
//for遍历
for(int ret : i) {
System.out.println(ret);
}
数组工具类Arrays和ArrayUtils
Arrays: rt.jar中java.util包下面的类
ArrayUtils: commons-lang.jar中org.apache.commons.lang3包下下面的类
Arrays方法
asList():将数组转为集合,转换后的集合不能修改长度,本质还是一个长度不可变的数组
sort(): 实现数组的排序
equals(): 比较两个数组是否相等
binarySearch(): 此法为二分搜索法,查询前需要用sort()方法将数组排序,返回查询值的下标
String[] strings = { "a", "d", "g", "e", "x", "j" };
Arrays.sort(strings);//排序
int binarySearch = Arrays.binarySearch(strings, "a");//返回下标
for (String string : strings) {
System.out.print(string + " ");
}
List<String> asList = Arrays.asList(strings);//转为集合
ArrayUtils方法
toArray(): 将可迭代对象转为数组
getLength(array) : 获取数组长度
isEmpty( array): 判断数组是否为空或为null
isSameLength(array1,,array2): 判断两个数组是否长度一致
nullToEmpty(array): 将null转化为相应数组
remove(array,int index): 根据数组下标删除元素
reverse(array): 反转数组元素
toString( array,"数组为null打印这句话"): 打印数组元素
toMap(array): 将数组转为Map,数组类型必须为Map.Entry or an Array这种类型
...
...
int [] arr1 = null;
int [] arr2 = ArrayUtils.nullToEmpty(arr1);