数组概述
什么是数组
- 数组：对于每一门编程语言来说都是重要的数据结构之一，在Java 中提供的数组是用来存储固定大小的同类型元素。
原因
- 原因：要知道，运行程序往往需要大量的数据，尤其是表达相同的一些数据。比如你输入的100名学生的成绩，我们要用它进行计算。我们不可能声明100个变量来存储这些数据，所以我们需要数据结构来存储一个元素个数固 定且元素类型下相同的有序集。
本质
- 本质：是一系列空间大小相等且地址连续的一片存储空间。 空间大小相等是为了方便维护数据，我们必须统一数据类型； 地址连续且大小相等：方便计算后续元素的具体物理内存地址。
注释
- 数组是一种引用数据类型，数据引用变量只是一个引用。
- 数组元素和数组变量在内存里是分开存放的，实际的数组元素被存储在堆（heap）内存中，存在堆内存的数据称为对象。
- 数组引用变量是一个引用类型的变量，被存储在栈（stack）内存中
- 创建数组时，必须明确大小和内容。
- 数组一旦定义下来，其长度不可改变；数组中有几个地址？就看数组有几个元素空间（数组 的长度）。
- 数组提供角标来访问数组里的元素。
数组的定义方式
创建数组只指定长度但不指定内容
数据类型 [ ] 数组名 = new 数据类型 [长度]
创建数组指定内容（同时长度就确定了）
数据类型[ ] 数组名 = new 数据类型[]{数据1, 数据2, 数据3, ..., 数据n};
数据类型[ ] 数组名 ={数据1, 数据2, 数据3, ..., 数据n};
示例1： 输入10个同学的成绩 求出成绩最高者 ，成绩最低者，以及平均值。
public class TestEclipse {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double [] score = new double[10];
double sum = 0;
double max = 0,min=100;
for(int i=0;i<10;i++) {
System.out.println("请输入第"+(i+1)+"位同学的java 成绩");
score[i] = sc.nextDouble();
sum+=score[i];
if(score[i]>max) {
max=score[i];
}else if(score[i]<min) {
min=score[i];
}
}
sc.close();
System.out.println("成绩最高： "+max);
System.out.println("成绩最低： "+min);
System.out.println("平均值： "+sum/10);
}二维数组
就是一个由行和列组成的一个表格而已，矩阵Matrix。 在这个矩阵中访问元素的话，是根据元素的行角标和列角标所确定的。
定义方式
直接为每一维分配空间，格式如下：
数据类型 [ ] [ ] 数组名 = new 数据类型 [数据行长度] [数据列长度];
int a[ ] [ ]= new int[2][3];
示例1：
int[][] arr = new int[2][3];
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
arr[i][j] = j;
System.out.print(arr[i][j] + " ");
}
System.out.println("");
}示例2： leetcode 62 路径规划问题
public static void main(String[] args) {
System.out.println("请输入你想生成的棋盘的长和宽：");
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
int y = sc.nextInt();
int [][] arr=new int[x][y];
bulid(arr,x,y);
way1(x,y);
System.out.println("总共有："+ way1(x,y)+"种方法");
}
private static void bulid(int[][] arr, int x ,int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print("0 ");
}
System.out.println("");
}
}
private static int way(int x, int y) {
int z = x+y-2;
int sum = 1;
for (int i = z; i >y-1; i--) {
sum*=i;
}
for (int i = 1; i <x; i++) {
sum=sum/i;
}
return sum;
}// 高中数学知识,但有溢出的风险
public static int way1(int m, int n) {
int[][] result=new int[m][n];
for(int i=0;i<m;i++) {
for(int j=0;j<n;j++) {
if(i==0||j==0) {
result[i][j]=1;
}else {
result[i][j]=result[i-1][j]+result[i][j-1];
}
}
}
return result[m-1][n-1];
}
// 动态规划是最优解常用数组操作（基础）
数组遍历
public class Array1 {
public static void main(String[] args) {
int[] arr = new int[] { 7, 2, 3, 5, 9, 6 };
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
for (int i : arr) {
System.out.println(i);
}
}
}数组排序
常见数组排序 ： 冒泡排序 ，选择排序 ，插入排序。
package com.openlab.day08.array;
import java.util.*;
public class TestZ2 {
public static void main(String[] args) {
int [] sc = new int [10];
int [] score = {100,99,46,66,75,89,76,87,69,88};
sort1(score);
for (int i : score) {
System.out.print(i+",");
}
}
public static void sort2(int[] score) {
for ( int i = 0; i < score.length-1; i++) {
int min =i;
for (int j = i+1; j < score.length; j++) {
if (score[j]<score[min]) {
min=j;
}
}
if (min!=i) {
swap(score,i,min);
}
}
} // 选择排序
public static void sort1(int[] score) {
for (int i = 1; i < score.length; i++) {
for (int j = i; j >0&&score[j]<score[j-1]; j--) {
swap(score,j,j-1);
}
}
}// 插入排序；
public static void sort(int[] score) {
for (int i = 0; i < score.length-1; i++) {
for (int j = 0; j < score.length-1-i; j++) {
if (score[j]>score[j+1]) {
swap(score, j, j+1);
}
}
}
}// 冒泡排序
public static void swap(int[]arr,int i, int j) {
arr[i] = arr[i] + arr[j];
arr[j] = arr[i] - arr[j];
arr[i] = arr[i] - arr[j];
}
}
数组查询
public class TestZ4 {
public static void main(String[] args) {
linearSearch();
binarySearch();
}
private static void linearSearch() {
int[] arr = { 6, 9, 1, 5, 2, 3, 8, 4, 7 };
int key = 8;
int index = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == key) {
index = i;
break;
}
}
System.out.println(index);
}//遍历查询
private static void binarySearch() {
int[] arr = { 6, 9, 1, 5, 2, 3, 8, 4, 7 };
int key = 8;
int min = 0;
int max = arr.length - 1;
int mid = (min + max) / 2;
while (arr[mid] != key) {
if (key < arr[mid]) {
max = mid - 1;
}
if (arr[mid] < key) {
min = mid + 1;
}
if (min > max) {
mid = -1;
break;
}
mid = (min + max) / 2;
}
System.out.println(mid);
}//二分查询
}
代码运行结果 : 6
6
数组扩容
public static void main(String[] args) {
int[] arr = new int[] { 1, 2, 3, 4, 5, 6 };
arr = arrayExpansion(arr, arr.length + 1);
}
private static int[] arrayExpansion(int[] origin, int newLen) {
int[] newArr = new int[newLen];
for (int i = 0; i < origin.length; i++) {
newArr[i] = origin[i];
}
return newArr;
}数组扩容，就是创建一个新的数组扩大它可存储的数据长度，将旧数组复制进去
Arrays数组工具类
Arrays类是JDK提供的专门用于操作数组的工具类，位于java.util包中。
用Arrays类的方法操作数组，无需自己编码。
常见操作：
- static int binarySearch(int[] a, int key) ：使用二分搜索法来搜索指定的 int 型数组，以获得指定 的值。
- static int[] copyOf(int[] original, int newLength) ：复制指定的数组，截取或用 0 填充（如有必 要），以使副本具有指定的长度。
- static boolean equals(int[] a, int[] a2) ：如果两个指定的 int 型数组彼此相等 ，则返回 true 。
- static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
- static String toString(int[] a) ：返回指定数组内容的字符串表示形式。
1. binarySearch(int[ ] a, int key)
import java.util.*;
public class TestF2 {
public static void main(String[] args) {
int a[] = new int[] {1, 3, 4, 6, 8, 9};
int x1 = Arrays.binarySearch(a, 4);
int x2 = Arrays.binarySearch(a, 9);
System.out.println( "x1:" + x1);
System.out.println( "x2:" + x2);
}
}
代码运行结果 ： x1:2
x2:5
2. int[ ] copyOf(int[ ] original, int newLength)
import java.util.*;
public class TestF2 {
public static void main(String[] args) {
int a[] = new int[] {1, 3, 4, 6, 8, 9};
int b[] ;
b = Arrays.copyOf(a, 7);
System.out.println(Arrays.toString(b));
}
}
代码运行结果：[1, 3, 4, 6, 8, 9, 0]
3.boolean equals(int[] a, int[] a2)
package day07;
import java.util.*;
public class TestF2 {
public static void main(String[] args) {
int a[] = new int[] {1, 3, 4, 6, 8, 9};
int b[] ,c[];
b = Arrays.copyOf(a, 7);
// 复制数组a 到 b ，将 b 数组的长度定为7
c = Arrays.copyOf(a, 6);
// 复制数组a 到 c ，将 c 数组的长度定为6
boolean flag = Arrays.equals(a,b);
boolean flag1 = Arrays.equals(a,c);
System.out.println(Arrays.toString(b));
System.out.println(flag);
System.out.println(Arrays.toString(c));
System.out.println(flag1);
}
}
代码运行结果： [1, 3, 4, 6, 8, 9, 0]
false
[1, 3, 4, 6, 8, 9]
true
4. sort(int[] a)
package day07;
import java.util.*;
public class TestF2 {
public static void main(String[] args) {
int a[] = new int[] {8, 3, 5, 6, 2, 1};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
}
代码运行结果：[1, 2, 3, 5, 6, 8]
5.’static String toString(int[ ] a)
package day07;
import java.util.*;
public class TestF2 {
public static void main(String[] args) {
int a[] = new int[] {8, 3, 5, 6, 2, 1};
Arrays.sort(a);
System.out.println(a);
System.out.println(Arrays.toString(a));
}
}
代码运行结果:[I@6d06d69c
[1, 2, 3, 5, 6, 8]
扫一扫
649
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
