数组(Array),是多个相同类型数据
按一定顺序排列
的集合,并使用一个名字命名
,并通过编号
的方式对这些数据进行统一管理。
引用数据类型
,而数组中的元素可以是任何数据类型
,包括基本数据类型和引用数据类型
。连续的空间
,而数组名中引用的是这块连续空间的首地址
。长度一旦确定,就不能修改
。 //1. 一维数组的声明和初始化
int num; //声明
num = 10;
int id = 1001;// 声明+ 初始化
int[] ids;//声明
//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001, 1002, 1003, 1004};
int id2[] = new int[]{1001, 1002, 1003, 1004};
//1.2 动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
int[] arr1 = new int[];
int[5] arr2 = new int[5];
int[] arr3 = new int[3]{1, 2,4};
//总结:数组一旦初始化完成,其长度就确定了
//(2)如何调用数组指定位置的元素:通过索引的方式调用
//数组的索引是从0开始的,到数组的长度-1结束
names[0] = "张三";
names[1] = "李四";
names[2] = "王五";
names[3] = "赵六";
names[4] = "孙七";
//3、如何获取数组的长度
//属性 length
System.out.println(ids.length);
System.out.println(names.length);
//4、如何遍历数组
for (int i = 0; i < ids.length; i++){
System.out.println(ids[i]);
}
for (int i = 0; i < names.length; i++){
System.out.println(names[i]);
}
数组是引用类型,它的元素相当于类的成员变量,因此数组一经分配空间,其中的每个元素也被按照成员变量同样的方式被隐式初始化。
数组元素类型 | 元素默认初始值 |
---|---|
byte | 0 |
short | 0 |
int | 0 |
long | 0L |
float | 0.0F |
double | 0.0 |
char | 0或写:‘\u0000’ (表现为空) |
boolean | false |
引用数据类型 | null |
System.out.println("----------byte数组初始化值-----------");
byte[] byteArray = new byte[1];
for (int i = 0; i < byteArray.length; i++) {
System.out.println(byteArray[i]);
}
System.out.println("----------short数组初始化值-----------");
short[] shortArray = new short[1];
for (int i = 0; i < shortArray.length; i++) {
System.out.println(shortArray[i]);
}
System.out.println("----------int数组初始化值-----------");
int[] intArray = new int[1];
for (int i = 0; i < intArray.length; i++) {
System.out.println(intArray[i]);
}
System.out.println("----------long数组初始化值-----------");
long[] longArray = new long[1];
for (int i = 0; i < longArray.length; i++) {
System.out.println(longArray[i]);
}
System.out.println("----------float数组初始化值-----------");
float[] floatArray = new float[1];
for (int i = 0; i < floatArray.length; i++) {
System.out.println(floatArray[i]);
}
System.out.println("----------double数组初始化值-----------");
double[] doubletArray = new double[1];
for (int i = 0; i < doubletArray.length; i++) {
System.out.println(doubletArray[i]);
}
System.out.println("----------char数组初始化值-----------");
char[] charArray = new char[1];
for (int i = 0; i < charArray.length; i++) {
System.out.println(charArray[i]);
}
System.out.println("----------boolean数组初始化值-----------");
boolean[] booleanArray = new boolean[1];
for (int i = 0; i < booleanArray.length; i++) {
System.out.println(booleanArray[i]);
}
System.out.println("----------引用类型数组初始化值-----------");
String[] stringArray = new String[1];
for (int i = 0; i < stringArray.length; i++) {
System.out.println(stringArray[i]);
}
----------byte数组初始化值-----------
0
----------short数组初始化值-----------
0
----------int数组初始化值-----------
0
----------long数组初始化值-----------
0
----------float数组初始化值-----------
0.0
----------double数组初始化值-----------
0.0
----------char数组初始化值-----------
----------boolean数组初始化值-----------
false
----------引用类型数组初始化值-----------
null
int[] arr = new int[]{1,2,3};
String[] arr1 = new String[4];
arr1[1] = "刘德华";
arr1[2] = "张学友";
arr1 = new String[3];
//1.二维数组的声明和初始化
int[] arr = new int[]{1, 2, 3};//一维数组
//静态初始化
int[][] arr1 = new int[][]{{1,2,3}, {4,5,6}, {7,8}};
//动态初始化
String[][] arr2 = new String[3][2];
String arr3[][] = new String[3][2];
String[] arr4[] = new String[3][2];
int[][]arr = new int[][3]; //非法
//静态初始化
int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8}};
//动态初始化1
int[][] arr2 = new int[3][2];
//动态初始化2
int[][] arr3 = new int[3][];
//这样也是正确的 但是不推荐
// int arr4[][];
// int[] arr4[];
//2、如何调用数组指定位置的元素
System.out.println(arr1[0][1]);//2
System.out.println(arr2[1][1]);//0
arr3[1] = new int[2];
System.out.println(arr3[1][1]);//0
//3、获取数组的长度
System.out.println(arr1.length);//3
System.out.println(arr1[0].length);//3
System.out.println(arr1[1].length);//3
//4、如何遍历二维数组
for(int i = 0; i < arr1.length; i++){
for (int j = 0; j < arr1[i].length; j++){
System.out.print(arr1[i][j] + " ");
}
System.out.println();
}
//int类型
int[][] arr = new int[3][];
System.out.println(arr[0]);// null
// System.out.println(arr[0][0]); //NullPointerException
System.out.println(arr); //[[I@1b6d3586
int[][] arr1 = new int[3][4];
System.out.println(arr1[0]);// [I@1b6d3586 地址值
System.out.println(arr1[0][0]); //0
System.out.println(arr1); //[[I@74a14482
//float类型
float[][] arr3 = new float[3][4];
System.out.println(arr3[0]);// [F@1540e19d 地址值
System.out.println(arr3[0][0]); //0.0
//String类型
String[][] arr4 = new String[3][4];
System.out.println(arr4[0]);// [Ljava.lang.String;@677327b6 地址值
System.out.println(arr4[0][0]); //null
int[][] arr1 = int[4][];
arr1[1] = new int[]{1,2,3};
arr1[2] = new int[4];
arr1[2][1] = 30;
int[4][] 中int[0]的值为null, 是因为此时的int[]引用类型没有赋值 所以是null
注意:x 表示int[] y 表示int[][] y[0] 表示int[]
声明:int[] x,y[];在给x,y变量赋值以后,以下选项允许通过编译的是:
a) x[0] = y;//错误 类型不一致 x是一维数组 y是二维数组
b) y[0] = x; //编译通过
c) y[0][0] = x;//y[0][0]表示的是值, x表示的是地址值
d) x[0][0] = y;//错误
e) y[0][0] = x[0];//编译通过
f) x = y; //错误 x表示int[],y表示int[][]
public static void main(String[] args) {
int[] array = {1,4,5,23,45,67};
int targetNum = -67;
binarySearch(array, targetNum);
}
public static void binarySearch(int[] source, int targetNum) {
int head = 0;
int end = source.length -1;
while(head <= end) {
int middle = (head+end)/2;
if (source[middle] > targetNum) {
end = middle - 1;
} else if (source[middle] < targetNum) {
head = middle + 1;
} else {
System.out.println("数据找到了" + source[middle] + "当前位置为" + middle);
break;
}
}
if (head > end) {
System.out.println("数据未找到" + targetNum);
}
}
介绍:
冒泡排序的原理非常简单,它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。
排序思想:
//冒泡排序
public static void bubbleSort(int[] source) {
for (int i = 0; i < source.length; i++) {
for (int i1 = i + 1; i1 < source.length; i1++) {
if (source[i] < source[i1]) {
int temp = source[i];
source[i] = source[i1];
source[i1] = temp;
continue;
}
}
}
for (int i : source) {
System.out.print(i + " ");
}
}
//改进
public static void bubbleSortUpgrade(int[] source) {
for (int i = 0; i < source.length-1; i++) {//最后一个数不用在继续比较啦
for (int i1 = i + 1; i1 < source.length-1-i; i1++) {//不用在和之前的数据去进行比较啦
if (source[i] < source[i1]) {
int temp = source[i];
source[i] = source[i1];
source[i1] = temp;
continue;
}
}
}
for (int i : source) {
System.out.print(i + " ");
}
}
//数组反转 方式一
public static void arrayInversion(int[] source) {
int[] newSource = new int[source.length];
for (int i = source.length - 1,j=0; i >= 0; i--,j++) {
newSource[j] = source[i];
}
for (int i : newSource) {
System.out.print(i + " ");
}
}
//数组反转 方式二
public static void arrayInversionTwo(int[] source) {
for (int i = 0; i < source.length/2; i++) {
int temp = source[i];
source[i] = source[source.length-i-1];
source[source.length-i-1] = temp;
}
for (int i : source) {
System.out.print(i + " ");
}
}
//获取最大值
public static void getArrayMax(int[] source) {
int max = source[0];
for (int i = 0; i < source.length; i++) {
if (max < source[i]) {
max = source[i];
}
}
System.out.println("max = " + max);
}
//获取最小值
public static void getArrayMin(int[] source) {
int min = source[0];
for (int i = 0; i < source.length; i++) {
if (min > source[i]) {
min = source[i];
}
}
System.out.println("min = " + min);
}
java.util.Arrays类即为操作数组的工具类,包含了用来操作数组(比如排序和搜索)的各种方法。
方法 | 作用 |
---|---|
boolean equals(boolean[] a, boolean[] a2) | 判断两个数组是否相等 |
String toString(int[] a) | 输出数组信息 |
void fill(int[] a, int val) | 将指定值填充到数组中 |
void sort(int[] a) | 对数组进行排序 |
int binarySearch(int[] a, int key) | 对排序后的数组进行二分法检索指定的值 |
int[] array = {99,76,64,43,33,32,32,21,0,-98};
int[] array1 = {99,76,64,43,33,32,32,21,0,-98};
int[] array3 = {99};
// System.out.println(Arrays.equals(array3, array2));
System.out.println(Arrays.equals(array1, array));
System.out.println(Arrays.toString(array));
System.out.println("------------填充之前--------------");
Arrays.fill(array, 156);
Arrays.fill(array, 0, 3, 157);
System.out.println(Arrays.toString(array));
System.out.println("------------填充之后--------------");
System.out.println("------------排序前--------------");
Arrays.sort(array1);
Arrays.sort(array1);
System.out.println(Arrays.toString(array1));
System.out.println("------------排序之后--------------");
// int[] array2 = {99,76,64,43,33,32,21,0,-98};
int[] array2 = {-98,0,21,32,33,43,64,76,99};
System.out.println(Arrays.binarySearch(array2, 33));//有序的数组,且从小到大排列
System.out.println(Arrays.binarySearch(array2, 64));
//System.out.println(Arrays.binarySearch(array2, 3));