Java学习记录
数组
数组是什么
数组有如下三个基本特性：
- 一致性：数组只能保存相同数据类型元素，元素的数据类型可以是任何相同的数据类型
- 有序性：数组中的元素是有序的，通过下标访问。
- 不可变性：数组一旦初始化，则长度（数组中元素的个数）不可变
数组有如下特点：
- 数组可以是一维数组、二维数组或多维数组。
- 数值数组元素的默认值为 0，而引用元素的默认值为 null。
- 数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。
- 数组元素可以是任何类型，包括数组类型。
- 数组类型是从抽象基类 Array 派生的引用类型。
数组的定义
数组是引用数据类型，引用数据类型在使用之前一定要做两件事情：声明和初始化。
创建一维数组
type[] arrayName; // 数据类型[] 数组名;
type arrayName[]; // 数据类型 数组名[];
动态初始化
public class Test {
public static void main(String[] args) {
//基本类型实例化后，在该内存空间的值就是默认值
int[] data = new int[5];
print(data);
//编译通过，运行发生空指针异常——NPE
int[] b=null;
print(b);
//引用类型默认值为null
String[] a=new String[9];
print(a);
}
public static void print(String[] i){
//i.length——length是属性
for(int j=0;j<i.length;j++){
System.out.println(i[j]);
}
}
}
静态初始化（开辟同时赋值）
//简化格式
数据类型[] 数组名称 = {值，值，....}
//完整格式
数据类型[] 数组名称 = new 数据类型[] {值，值，....}
- 匿名数组：在栈内存中没有任何引用，只在堆内存开辟空间，存放数据
public class ArrayTest{
public static void main(String [] args){
System.out.println(new int[]{1,2,3}.length);
}
public class ArrayTest {
public static void main(String[] args) {
int[] a = new int[]{1, 2, 3};
int[] b = new int[]{4, 5, 6, 7, 8};
//动态初始化
int[] c = new int[a.length + b.length];
for (int i = 0; i < a.length; i++) {
c[i] = a[i];
}
for (int i = a.length; i < c.length; i++) {
c[i] = b[i - a.length];
}
for (int i = 0; i < c.length; i++) {
System.out.print(c[i] + " ");
}
}
}
二维数组
- 二维数组中，a.length表示行数，a[i].length表示i行的列数
- 动态初始化时，多为数组的行数不可省略，列数可省略
public class Test3{
public static void main(String[] args) {
int[][] arr=new int[3][]; //-> arr=int[3][]{null,null,null}
//如果没有下面三行，则会出现空指针异常
arr[0]=new int[6]; //int[6]={0,0,0,0,0,0} -> arr=int[3][]{int[6]{0,0,0,0,0,0},null,null}
arr[1]=new int[6];
arr[2]=new int[6];
arr[0][1]=2; //arr=int[3][]{int[6]{0,2,0,0,0,0},null,null} (假设没有第12.13行)
arr[1][3]=5;
arr[2][5]=8;
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();
}
}
}
- 动态初始化
public class ArrayTest {
public static void main(String[] args) {
//动态初始化
int[][] a = new int[2][3];
a[0][0] = 2;
a[1][2] = 5;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + "\t");
}
System.out.println();
}
}
}
- 静态初始化
public class ArrayTest {
public static void main(String[] args) {
int[][] a = new int[][]{{1, 2}, {3, 5, 6, 4, 1}, {8, 9, 7}};
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + "\t");
}
System.out.println();
}
}
}
数组与方法互操作
给一个方法中传入数组类型，在引用传递的情况下，如果新数组对值进行改变，则原数组的值也随之改变
- 扩展数组织
public class ArrayExpend {
public static void main(String[] args) {
int[] a = new int[]{1, 2, 3, 4};
System.out.println("数组a：");
arrayPrint(a);
int[] result1 = arrayExpend(a);
System.out.println("扩展结果：");
arrayPrint(result1);
System.out.println("after数组a：");
arrayPrint(a);
int[] result2 = arrayExpend2(a);
System.out.println("扩展结果：");
arrayPrint(result2);
System.out.println("after数组a：");
arrayPrint(a);
}
public static int[] arrayExpend(int[] a) {
if (a == null) {
return new int[]{};
}
//数组引用传递
int[] temp = a;
for (int i = 0; i < a.length; i++) {
temp[i] = temp[i] * 5;
}
return temp;
}
public static int[] arrayExpend2(int[] a) {
if (a == null) {
return new int[]{};
}
//空间重新分配
int[] temp = new int[a.length];
for (int i = 0; i < a.length; i++) {
temp[i] = a[i] * 4;
}
return temp;
}
public static void arrayPrint(int[] c) {
if (c == null) {
return;
}
for (int j = 0; j < c.length; j++) {
System.out.print(c[j] + " ");
}
System.out.println();
}
}
java对数组的支持
数字升序排序
import java.util.Arrays;
public class ArrayUtil {
public static void main(String[] args) {
int[] a = new int[]{1, 33, 5, 44, 76};//1,5,33,44,76
System.out.println("排序之前：");
arrayPrint(a);
Arrays.sort(a);
System.out.println("排序之后：");
//改变原数组
arrayPrint(a);
}
public static void arrayPrint(int[] c) {
if (c == null) {
return;
}
for (int j = 0; j < c.length; j++) {
System.out.print(c[j] + " ");
}
System.out.println();
}
}
拷贝
- 方法一
java.lang.System.arraycopy(Object src,int srcPos,Object dest, int destPos,int length);
public class ArrayUtil {
//拷贝
public static void main(String[] args) {
int[] src = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
int[] dest = new int[3];
arrayPrint(src);
arrayPrint(dest);
//方法一
// for(int i=2;i<5;i++){
// dest[i-2]=src[i];
// }
//方法二
System.arraycopy(src, 2, dest, 0, 3);
arrayPrint(src);
arrayPrint(dest);
}
public static void arrayPrint(int[] c) {
if (c == null) {
return;
}
for (int j = 0; j < c.length; j++) {
System.out.print(c[j] + " ");
}
System.out.println();
}
}
- 方法二
复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
java.util.Arrays.copyOf(源数组名称,新数组长度)
import java.util.Arrays;
public class ArrayUtil {
public static void main(String[] args) {
int[] src = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
arrayPrint(src);
int[] dest1 = Arrays.copyOf(src, 7);
//Arrays.copyOf不改变原数组
arrayPrint(src);
arrayPrint(dest1);
int[] dest2 = Arrays.copyOf(src, 10);
arrayPrint(dest2);
}
public static void arrayPrint(int[] c) {
if (c == null) {
return;
}
for (int j = 0; j < c.length; j++) {
System.out.print(c[j] + " ");
}
System.out.println();
}
}
