1.数组的概念
1.1数组的创建和初始化
T[] 数组名 = new T[N];- T：表示数组中存放元素的类型
- T[]：表示数组的类型
- N：表示数组的长度
示例：
int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组1.2数组的初始化
数组初始化分为动态初始化和静态初始化
1.
动态初始化：在创建数组时，直接指定数组中元素的个数
int[] array = new int[10];
2.
静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
语法格式：
T[]
数组名称
= {data1, data2, data3, ..., datan}
;
int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"};
【注意事项】
- 静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
- 静态初始化时, {}中数据类型必须与[]前数据类型一致。
- 静态初始化可以简写，省去后面的new T[]。
如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值
如果数组中存储元素类型为引用类型，默认值为null
2.数组的基本操作
2.1数组元素的访问
int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);2.2数组的遍历
"
遍历
"
是指将数组中的所有元素都访问一遍
,
访问是指对数组中的元素进行某种操作
public static void main(String[] args) {
int[] array={1,2,3,4,5};
for(int i=0;i<5;i++){
System.out.println(array[i]);
}
}
注意：
在数组中可以通过
数组对象
.length
来获取数组的长度
也可以使用
for-each
遍历数组
public static void main(String[] args) {
int[] array={1,2,3,4,5};
for(int x:array){
System.out.println(x);
}
}3.数组的特征
3.1数组是引用类型
基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；
而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。
public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}
在上述代码中，
a
、
b
、
arr
，都是函数内部的变量，因此其空间都在
main
方法对应的栈帧中分配。
a
、
b
是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。
array
是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。
引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地
址，引用变量便可以去操作对象
。类似于C语言的指针。
3.2认识 null
null
在
Java
中表示
"
空引用
" ,
也就是一个不指向对象的引用
.
int[] arr = null;
System.out.println(arr[0]);
// 执行结果 Exception in thread "main" java.lang.NullPointerException
at Test.main(Test.java:6)
null
的作用类似于
C
语言中的
NULL (
空指针
),
都是表示一个无效的内存位置
.
因此不能对这个内存进行任何读写操作
. 一旦尝试读写,
就会抛出
NullPointerException.
注意
: Java
中并没有约定
null
和
0
号地址的内存有任何关联
4.数组使用
4.1数组转字符
import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
// 执行结果 [1, 2, 3, 4, 5, 6]4.2数组拷贝
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
int[] newArr = arr;
System.out.println( Arrays.toString(arr));
newArr = Arrays.copyOf(arr, arr.length);
System.out.println( Arrays.toString(newArr));
}拷贝某个范围
int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
System.out.println(Arrays.toString(newArr2));实现拷贝这个功能 my_copy
public static int[] copyOf(int[] arr) {
int[] ret = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i];
}
return ret;
}4.3查找数组中指定元素(顺序查找)
public static void main(String[] args) {
int[]arr={1,2,3,4,5,6,7,8};
System.out.println(Find(arr,8));
}
public static int Find(int[]arr,int num){
for(int i=0;i<arr.length;i++){
if(arr[i]==num){
return i;
}
}
return -1;
}
4.4查找数组中指定元素(二分查找)
针对有序数组可以进行二分查找
public static void main(String[] args) {
int[]arr={1,2,3,4,5,6,7,8,9};
System.out.println(Search(arr,6));
}
public static int Search(int[]arr,int num){
int left=0;
int right=arr.length-1;
while(left<=right){
int mid=(left+right)/2;
if(num<arr[mid]){
right=mid-1;
}else if(num>arr[mid]){
left=mid+1;
}else{
return mid;
}
}
return -1;
}
4.5数组排序(冒泡排序)
public static void main(String[] args) {
int[]arr={3,4,2,7,9,6};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int[]arr){
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 tmp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=tmp;
}
}
}
}4.6Java里内置了更高效的排序函数
public static void main(String[] args) {
int[] arr = {9, 5, 2, 7};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}4.7数组逆序
思路
- 设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
- 然后让前一个下标自增, 后一个下标自减, 循环继续即可.
public static void main(String[] args) {
int[]arr={1,2,3,4,5,6,7,8};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public 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--;
}
}