4.数组、排序、查找

一、数组 [ ]

数组:可以存放多个同一类型的数据
数组的下标从 0 开始

1. 动态初始化 - 确定元素数量

方式 1

1
2
3
4
数组类型 数组名[] = new 数组类型[大小]

// 创建一个数组,数组名为 a ,可以存放 5 个 int 类型的元素
int a[] = new int[5];

方式 2

1
2
3
4
5
数组类型 数组名[]; 或 数组类型[] 数组名;
数组名 = new 数据类型[大小];

int a[];
a = new int[5];

2.静态初始化 - 不确定元素数量

1
2
3
数据类型 数组名[] = {元素,元素,元素...}

int a[] = {2,5,7,8,99,2,4,5,};
  1. 数组是多个相同类型的数据组合,不同类型的数据不能放到同一数组中
  2. 数组创建后,如果没有赋值,则默认值为 byte、short、int、long 为 0,float、double 为 0.0,char 为\u0000, boolean 为 false, String 为 null
  3. 数组的下标从 0 开始
  4. 不同类型存放时需要遵循 数据自动类型转换 规则

3. 数组拷贝

1
2
3
4
5
int a = 10;
int b = a;

b = 80;
// a 等于 10, b 等于 80
1
2
3
4
5
int a[] = {1,2,3};
int b[] = a;

b[0] = 10;
// a 等于 {10,2,3}, b 等于 {10,2,3}

值拷贝不会改变原来的数据,引用赋值会改变原始数据,赋值实际上是原始数据的内存地址;
如果需要得到不影响原始数据的数组,可以通过遍历获取新的数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class demo01{
public static void main(String[] args) {
int arr1[] = {1,2,3};
int arr2[] = new int[arr1.length];

// 重新给 arr2 赋值
for(int i = 0; i< arr1.length; i++){
arr2[i] = arr1[i];
}

arr2[0] = 999;
for (int i = 0; i<arr2.length; i++) {
System.out.println(arr2[i]);
System.out.println(arr1[i]);
}
}
}

4.数组反转

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class demo01{
public static void main(String[] args) {
int arr1[] = {11,22,33,44,55,66};
int num = arr1.length;
for (int i = 0; i< num/2; i++ ) {
int temp = arr1[i];
arr1[i] = arr1[num-1-i];
arr1[num-1-i] = temp;
}
for (int i = 0; i<=arr1.length-1; i++ ) {
System.out.println(arr1[i]);
}
}
}

5.数组添加

1
2
3
4
5
6
7
8
9
10
11
12
13
public class demo01{
public static void main(String[] args) {
int arr1[] = {1,2,3};
int arr2[] = new int[arr1.length + 1];
for (int i = 0; i< arr1.length;i++ ) {
arr2[i] = arr1[i];
}
arr2[arr2.length -1] = 4;
for (int i = 0; i< arr2.length;i++ ) {
System.out.print(arr2[i] + " ");
}
}
}

二、排序

排序: 将多个数据,依指定的顺序进行排序的过程

  1. 内部排序
    1. 将需要处理的数据加载到内存中进行排序
    2. 交换式排序、选择排序、插入式排序
  2. 外部排序
    1. 数据量过大,需要借助外部存储进行排序
    2. 合并排序,直接合并排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class demo01{
public static void main(String[] args) {
int arr[] = {24,69,80,587,13};
for (int i = 0; i <arr.length-1 ;i++ ) {
for (int j = 0; j< arr.length -i -1;j++ ) {
if (arr[j] > arr[j+1]) {
int tamp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tamp;
}
}
}
for (int i = 0; i < arr.length ;i++ ) {
System.out.print(arr[i]+ "\t");
}
}
}

三、查找

1.按顺序查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.Scanner;
public class demo01{
public static void main(String[] args) {
String arr[] = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
Scanner myScanner = new Scanner(System.in);

System.out.print("请输入明教护法的名字:");
String name = myScanner.next();

for (int i = 0; i < arr.length -1; i++) {
if (name.equals(arr[i])) {
System.out.print("找到了,下标为" + i);
return;
}
}
}
}

2.二分法查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
* 从数组中查找目标元素的下标
* @param arr 目标数组
* @param dest 目标元素
* @return -1表示该元素不存在,返回其它表示返回该元素的下标
*/
public static int binarySearch2(int[]arr,int dest) {

// 下标
int begin = 0;
int end = arr.length-1;

// 开始元素的下标只要在结束元素的下标发左边,就可以继续循环
while (begin <= end){
// 中间元素下标
int mid = (begin + end) / 2;
if (arr[mid] == dest){
return mid;
}else if (arr[mid] < dest){
// 目标在中间元素的右边
// 开始元素下标发生改变
begin = mid + 1; // 一直增
}else {
// arr[mid] > dest
// 目标在中间元素的左边
end = mid - 1; // 一直减
}
}
return -1;
}

四、二维数组

1
2
3
4
类型[][] 数组名 = new 类型[大小][大小]
数组类型[][] 数组名 = {{元素,元素},{元素,元素},{元素,元素}};

int[][] arr = {{0,1,2},{1,2,3},{7,6,3}};
1
2
3
4
5
6
7
8
9
10
11
public class demo01{
public static void main(String[] args) {
int[][] arr = {{0,0,0,0,0,0},{0,0,1,0,0,0},{0,2,0,3,0,0},{0,0,0,0,0,0}};
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();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class demo01{
public static void main(String[] args) {
int arr[][] = new int[10][];
for (int i=0; i<arr.length; i++) {

// 二维数组空间创建
arr[i] = new int[i+1];

for (int j=0;j<arr[i].length ;j++ ) {
if (j == 0 || j == arr[i].length -1) {
arr[i][j]=1;
}else {
arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
}
}
}
// 遍历二维数组
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();
}
}
}