数组知识的回顾

## 数组

数组的概念:

数组是一个变量,用来存放一组相同数据类型变量的容器。

数组的格式:

* 数据类型[ ] 数组名;

* 数据类型 数组名[ ];

数组的属性:通过arr.length来表示数组的长度。

数组异常:

1.下标越界。比如如下代码:

```java

public class Array {

public static void main(String[] args) {

// 声明数组

int[] arr =new int[3] ;

//给数组每一个元素赋值

arr[0]=6;

arr[1]=12;

arr[2]=26;

arr[3]=3;//数组的下标不在 0~arr.length之间

System.out.println(Arrays.toString(arr));

}

}

```

  2.空指针。如下代码:

```java

public class Array {

public static void main(String[] args) {

//对象没有new,就访问对象成员

int[] arr2 = null;

System.out.println(arr2[1]); // java.lang.NullPointerException

}

}

```

数组的初始化

静态初始化

格式一: 数据类型[ ] 数组名 = {元素1,元素2,...元素n};

格式二: 数据类型[ ] 数组名 = new int[]{元素1,元素2,...元素n};

动态初始化

数据类型[ ] 数组名 = new 数据类型[数组的大小];

可以采用以下三种方式初始化

1.逐个初始化

2.通过键盘输入

3.通过随机数初始化

***注意不管是静态初始化还是动态初始化,一定在创建的时候,就指明数 组的长度。数组的长度一旦确定,就不可以更改。

1.逐个初始化

```java

public class Array {

public static void main(String[] args) {

int[] arr = new int[3];

arr[0] =10;

arr[1] = 8;

arr[2] = 50;

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

}

}

```

2.通过键盘输入

* 举例:Java考试结束后,老师给冰冰分配了一项任务,让他计算全班(30人)的平均分。

```java

import java.util.Scanner;

public class ArraysDemo01 {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner input = new Scanner(System.in);

double [] score = new double [30];

double sum = 0.0;

double average = 0.0;

for (int i = 0; i < score.length; i++) {

System.out.print("请输入第" + (i + 1) + "个学生成绩: ");

score[i] = input.nextDouble();

sum+= score[i];

}

average = sum/score.length;

System.out.println(score.length+"个学生成绩的平均分是: "+average);

}

}

```

3.随机数初始化

```java

public class Array {

public static void main(String[] args) {

int[] arr = new int[ ]{10,20,30,40,50};

for (int i = 0; i < arr.length; i++) {

arr[i] = (int) (Math.random() * 10);

}

System.out.println(Arrays.toString(arr));

}

}

```

数组的遍历

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

##举例:有一个数列:8,4,2,1,23,344,12,循环输出数列的值。

```java

public class Array {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

String s = arrayToString(arr);

System.out.println(arrayToString(arr));

}

public static String arrayToString(int[] arr) {

String result = "";

result += "[";

for (int i = 0; i < arr.length; i++) {

if (i == arr.length - 1) {

result += arr[i];

} else {

result += arr[i] + ", ";

}

}

result += "]"

return result;

}

}

```

数组的最值思想

举例:有一个数列:9,5,1,10,89,569,16,求出最大值和最小值。

```java

//求上述数列的最大值

public class Array {

public static void main(String[] args) {

int[] arr = {9,5,1,10,89,569,16};

System.out.println("最大值:" + getMaxValue(arr));

}

    public static int getMaxValue(int[] arr) {

// 1.假设第一个数为最大值

int max = arr[0];

// 2.遍历数组中的每一个元素

for (int i = 0; i < arr.length; i++) {

// 获取到每一个元素arr[i]

// 3.判断获取的元素是否比max大

if (arr[i] > max) {

// 4.设置arr[i]为最大值

max = arr[i];

}

}

return max;

}

}

```

```java

//求上述数列的最小值

public class Array {

public static void main(String[] args) {

int[] arr = {9,5,1,10,89,569,16};

System.out.println("最大值:" + getMinValue(arr));

}

    public static int getMinValue(int[] arr) {

// 1.假设第一个数为最小值

int min = arr[0];

// 2.遍历数组中的每一个元素

for (int i = 0; i < arr.length; i++) {

// 获取到每一个元素arr[i]

// 3.判断获取的元素是否比min大

if (arr[i]

// 4.设置arr[i]为最小值

min = arr[i];

}

}

return max;

}

}

```

数组倒置思想

举例:有一个数列:8,4,2,1,23,344,12,将数组倒置并输出。

```java

public class Array {

public static void main(String[] args) {

  int[] arr = {8,4,2,1,23,344,12};

  System.out.println("倒置前: " + arrays.toString(arr));

  reverseArray(arr);

  System.out.println("倒置后: " + arrays.toString(arr));

}

public static void reverseArray(int[] arr) {

  for (int i = 0; i < arr.length / 2; i++) {

int temp = 0;

temp = arr[i];

arr[i] = arr[arr.length - 1 - i];

arr[arr.length - 1 - i] = temp;

}

}

```

数组查找思想

举例:有一个数列:8,4,2,1,23,344,12,数组查找 猜数游戏:从键盘中任意输入一个数据,判断数列中是否包含此数。

```java

public class ArrayDemo06 {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

Scanner input = new Scanner(System.in);

    int num = input.nextInt();

    int index = baiscSearch(arr, num);

System.out.println(index != -1 ? "找到了该数" + arr[index] : "该数在数组中不存在");

}

public static int baiscSearch(int[] arr, int num) {

int index = -1;

for (int i = 0; i < arr.length; i++) {

if (arr[i] == num) {

index = i;

break;

}

}

return index;

}

}

```

数组排列思想(冒泡排列)

举例:有一个数列:8,4,2,1,23,344,12,数组排序。

```java

public class ArrayDemo06 {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

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 temp = 0;

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

      }

}

}

}

}

```## 数组

数组的概念:

数组是一个变量,用来存放一组相同数据类型变量的容器。

数组的格式:

* 数据类型[ ] 数组名;

* 数据类型 数组名[ ];

数组的属性:通过arr.length来表示数组的长度。

数组异常:

1.下标越界。比如如下代码:

```java

public class Array {

public static void main(String[] args) {

// 声明数组

int[] arr =new int[3] ;

//给数组每一个元素赋值

arr[0]=6;

arr[1]=12;

arr[2]=26;

arr[3]=3;//数组的下标不在 0~arr.length之间

System.out.println(Arrays.toString(arr));

}

}

```

  2.空指针。如下代码:

```java

public class Array {

public static void main(String[] args) {

//对象没有new,就访问对象成员

int[] arr2 = null;

System.out.println(arr2[1]); // java.lang.NullPointerException

}

}

```

数组的初始化

静态初始化

格式一: 数据类型[ ] 数组名 = {元素1,元素2,...元素n};

格式二: 数据类型[ ] 数组名 = new int[]{元素1,元素2,...元素n};

动态初始化

数据类型[ ] 数组名 = new 数据类型[数组的大小];

可以采用以下三种方式初始化

1.逐个初始化

2.通过键盘输入

3.通过随机数初始化

***注意不管是静态初始化还是动态初始化,一定在创建的时候,就指明数 组的长度。数组的长度一旦确定,就不可以更改。

1.逐个初始化

```java

public class Array {

public static void main(String[] args) {

int[] arr = new int[3];

arr[0] =10;

arr[1] = 8;

arr[2] = 50;

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

}

}

```

2.通过键盘输入

* 举例:Java考试结束后,老师给冰冰分配了一项任务,让他计算全班(30人)的平均分。

```java

import java.util.Scanner;

public class ArraysDemo01 {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner input = new Scanner(System.in);

double [] score = new double [30];

double sum = 0.0;

double average = 0.0;

for (int i = 0; i < score.length; i++) {

System.out.print("请输入第" + (i + 1) + "个学生成绩: ");

score[i] = input.nextDouble();

sum+= score[i];

}

average = sum/score.length;

System.out.println(score.length+"个学生成绩的平均分是: "+average);

}

}

```

3.随机数初始化

```java

public class Array {

public static void main(String[] args) {

int[] arr = new int[ ]{10,20,30,40,50};

for (int i = 0; i < arr.length; i++) {

arr[i] = (int) (Math.random() * 10);

}

System.out.println(Arrays.toString(arr));

}

}

```

数组的遍历

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

##举例:有一个数列:8,4,2,1,23,344,12,循环输出数列的值。

```java

public class Array {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

String s = arrayToString(arr);

System.out.println(arrayToString(arr));

}

public static String arrayToString(int[] arr) {

String result = "";

result += "[";

for (int i = 0; i < arr.length; i++) {

if (i == arr.length - 1) {

result += arr[i];

} else {

result += arr[i] + ", ";

}

}

result += "]"

return result;

}

}

```

数组的最值思想

举例:有一个数列:9,5,1,10,89,569,16,求出最大值和最小值。

```java

//求上述数列的最大值

public class Array {

public static void main(String[] args) {

int[] arr = {9,5,1,10,89,569,16};

System.out.println("最大值:" + getMaxValue(arr));

}

    public static int getMaxValue(int[] arr) {

// 1.假设第一个数为最大值

int max = arr[0];

// 2.遍历数组中的每一个元素

for (int i = 0; i < arr.length; i++) {

// 获取到每一个元素arr[i]

// 3.判断获取的元素是否比max大

if (arr[i] > max) {

// 4.设置arr[i]为最大值

max = arr[i];

}

}

return max;

}

}

```

```java

//求上述数列的最小值

public class Array {

public static void main(String[] args) {

int[] arr = {9,5,1,10,89,569,16};

System.out.println("最大值:" + getMinValue(arr));

}

    public static int getMinValue(int[] arr) {

// 1.假设第一个数为最小值

int min = arr[0];

// 2.遍历数组中的每一个元素

for (int i = 0; i < arr.length; i++) {

// 获取到每一个元素arr[i]

// 3.判断获取的元素是否比min大

if (arr[i]

// 4.设置arr[i]为最小值

min = arr[i];

}

}

return max;

}

}

```

数组倒置思想

举例:有一个数列:8,4,2,1,23,344,12,将数组倒置并输出。

```java

public class Array {

public static void main(String[] args) {

  int[] arr = {8,4,2,1,23,344,12};

  System.out.println("倒置前: " + arrays.toString(arr));

  reverseArray(arr);

  System.out.println("倒置后: " + arrays.toString(arr));

}

public static void reverseArray(int[] arr) {

  for (int i = 0; i < arr.length / 2; i++) {

int temp = 0;

temp = arr[i];

arr[i] = arr[arr.length - 1 - i];

arr[arr.length - 1 - i] = temp;

}

}

```

数组查找思想

举例:有一个数列:8,4,2,1,23,344,12,数组查找 猜数游戏:从键盘中任意输入一个数据,判断数列中是否包含此数。

```java

public class ArrayDemo06 {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

Scanner input = new Scanner(System.in);

    int num = input.nextInt();

    int index = baiscSearch(arr, num);

System.out.println(index != -1 ? "找到了该数" + arr[index] : "该数在数组中不存在");

}

public static int baiscSearch(int[] arr, int num) {

int index = -1;

for (int i = 0; i < arr.length; i++) {

if (arr[i] == num) {

index = i;

break;

}

}

return index;

}

}

```

数组排列思想(冒泡排列)

举例:有一个数列:8,4,2,1,23,344,12,数组排序。

```java

public class ArrayDemo06 {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

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 temp = 0;

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

      }

}

}

}

}

```## 数组

数组的概念:

数组是一个变量,用来存放一组相同数据类型变量的容器。

数组的格式:

* 数据类型[ ] 数组名;

* 数据类型 数组名[ ];

数组的属性:通过arr.length来表示数组的长度。

数组异常:

1.下标越界。比如如下代码:

```java

public class Array {

public static void main(String[] args) {

// 声明数组

int[] arr =new int[3] ;

//给数组每一个元素赋值

arr[0]=6;

arr[1]=12;

arr[2]=26;

arr[3]=3;//数组的下标不在 0~arr.length之间

System.out.println(Arrays.toString(arr));

}

}

```

  2.空指针。如下代码:

```java

public class Array {

public static void main(String[] args) {

//对象没有new,就访问对象成员

int[] arr2 = null;

System.out.println(arr2[1]); // java.lang.NullPointerException

}

}

```

数组的初始化

静态初始化

格式一: 数据类型[ ] 数组名 = {元素1,元素2,...元素n};

格式二: 数据类型[ ] 数组名 = new int[]{元素1,元素2,...元素n};

动态初始化

数据类型[ ] 数组名 = new 数据类型[数组的大小];

可以采用以下三种方式初始化

1.逐个初始化

2.通过键盘输入

3.通过随机数初始化

***注意不管是静态初始化还是动态初始化,一定在创建的时候,就指明数 组的长度。数组的长度一旦确定,就不可以更改。

1.逐个初始化

```java

public class Array {

public static void main(String[] args) {

int[] arr = new int[3];

arr[0] =10;

arr[1] = 8;

arr[2] = 50;

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

}

}

```

2.通过键盘输入

* 举例:Java考试结束后,老师给冰冰分配了一项任务,让他计算全班(30人)的平均分。

```java

import java.util.Scanner;

public class ArraysDemo01 {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner input = new Scanner(System.in);

double [] score = new double [30];

double sum = 0.0;

double average = 0.0;

for (int i = 0; i < score.length; i++) {

System.out.print("请输入第" + (i + 1) + "个学生成绩: ");

score[i] = input.nextDouble();

sum+= score[i];

}

average = sum/score.length;

System.out.println(score.length+"个学生成绩的平均分是: "+average);

}

}

```

3.随机数初始化

```java

public class Array {

public static void main(String[] args) {

int[] arr = new int[ ]{10,20,30,40,50};

for (int i = 0; i < arr.length; i++) {

arr[i] = (int) (Math.random() * 10);

}

System.out.println(Arrays.toString(arr));

}

}

```

数组的遍历

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

##举例:有一个数列:8,4,2,1,23,344,12,循环输出数列的值。

```java

public class Array {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

String s = arrayToString(arr);

System.out.println(arrayToString(arr));

}

public static String arrayToString(int[] arr) {

String result = "";

result += "[";

for (int i = 0; i < arr.length; i++) {

if (i == arr.length - 1) {

result += arr[i];

} else {

result += arr[i] + ", ";

}

}

result += "]"

return result;

}

}

```

数组的最值思想

举例:有一个数列:9,5,1,10,89,569,16,求出最大值和最小值。

```java

//求上述数列的最大值

public class Array {

public static void main(String[] args) {

int[] arr = {9,5,1,10,89,569,16};

System.out.println("最大值:" + getMaxValue(arr));

}

    public static int getMaxValue(int[] arr) {

// 1.假设第一个数为最大值

int max = arr[0];

// 2.遍历数组中的每一个元素

for (int i = 0; i < arr.length; i++) {

// 获取到每一个元素arr[i]

// 3.判断获取的元素是否比max大

if (arr[i] > max) {

// 4.设置arr[i]为最大值

max = arr[i];

}

}

return max;

}

}

```

```java

//求上述数列的最小值

public class Array {

public static void main(String[] args) {

int[] arr = {9,5,1,10,89,569,16};

System.out.println("最大值:" + getMinValue(arr));

}

    public static int getMinValue(int[] arr) {

// 1.假设第一个数为最小值

int min = arr[0];

// 2.遍历数组中的每一个元素

for (int i = 0; i < arr.length; i++) {

// 获取到每一个元素arr[i]

// 3.判断获取的元素是否比min大

if (arr[i]

// 4.设置arr[i]为最小值

min = arr[i];

}

}

return max;

}

}

```

数组倒置思想

举例:有一个数列:8,4,2,1,23,344,12,将数组倒置并输出。

```java

public class Array {

public static void main(String[] args) {

  int[] arr = {8,4,2,1,23,344,12};

  System.out.println("倒置前: " + arrays.toString(arr));

  reverseArray(arr);

  System.out.println("倒置后: " + arrays.toString(arr));

}

public static void reverseArray(int[] arr) {

  for (int i = 0; i < arr.length / 2; i++) {

int temp = 0;

temp = arr[i];

arr[i] = arr[arr.length - 1 - i];

arr[arr.length - 1 - i] = temp;

}

}

```

数组查找思想

举例:有一个数列:8,4,2,1,23,344,12,数组查找 猜数游戏:从键盘中任意输入一个数据,判断数列中是否包含此数。

```java

public class ArrayDemo06 {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

Scanner input = new Scanner(System.in);

    int num = input.nextInt();

    int index = baiscSearch(arr, num);

System.out.println(index != -1 ? "找到了该数" + arr[index] : "该数在数组中不存在");

}

public static int baiscSearch(int[] arr, int num) {

int index = -1;

for (int i = 0; i < arr.length; i++) {

if (arr[i] == num) {

index = i;

break;

}

}

return index;

}

}

```

数组排列思想(冒泡排列)

举例:有一个数列:8,4,2,1,23,344,12,数组排序。

```java

public class ArrayDemo06 {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

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 temp = 0;

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

      }

}

}

}

}

```## 数组

数组的概念:

数组是一个变量,用来存放一组相同数据类型变量的容器。

数组的格式:

* 数据类型[ ] 数组名;

* 数据类型 数组名[ ];

数组的属性:通过arr.length来表示数组的长度。

数组异常:

1.下标越界。比如如下代码:

```java

public class Array {

public static void main(String[] args) {

// 声明数组

int[] arr =new int[3] ;

//给数组每一个元素赋值

arr[0]=6;

arr[1]=12;

arr[2]=26;

arr[3]=3;//数组的下标不在 0~arr.length之间

System.out.println(Arrays.toString(arr));

}

}

```

  2.空指针。如下代码:

```java

public class Array {

public static void main(String[] args) {

//对象没有new,就访问对象成员

int[] arr2 = null;

System.out.println(arr2[1]); // java.lang.NullPointerException

}

}

```

数组的初始化

静态初始化

格式一: 数据类型[ ] 数组名 = {元素1,元素2,...元素n};

格式二: 数据类型[ ] 数组名 = new int[]{元素1,元素2,...元素n};

动态初始化

数据类型[ ] 数组名 = new 数据类型[数组的大小];

可以采用以下三种方式初始化

1.逐个初始化

2.通过键盘输入

3.通过随机数初始化

***注意不管是静态初始化还是动态初始化,一定在创建的时候,就指明数 组的长度。数组的长度一旦确定,就不可以更改。

1.逐个初始化

```java

public class Array {

public static void main(String[] args) {

int[] arr = new int[3];

arr[0] =10;

arr[1] = 8;

arr[2] = 50;

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

}

}

```

2.通过键盘输入

* 举例:Java考试结束后,老师给冰冰分配了一项任务,让他计算全班(30人)的平均分。

```java

import java.util.Scanner;

public class ArraysDemo01 {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner input = new Scanner(System.in);

double [] score = new double [30];

double sum = 0.0;

double average = 0.0;

for (int i = 0; i < score.length; i++) {

System.out.print("请输入第" + (i + 1) + "个学生成绩: ");

score[i] = input.nextDouble();

sum+= score[i];

}

average = sum/score.length;

System.out.println(score.length+"个学生成绩的平均分是: "+average);

}

}

```

3.随机数初始化

```java

public class Array {

public static void main(String[] args) {

int[] arr = new int[ ]{10,20,30,40,50};

for (int i = 0; i < arr.length; i++) {

arr[i] = (int) (Math.random() * 10);

}

System.out.println(Arrays.toString(arr));

}

}

```

数组的遍历

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

##举例:有一个数列:8,4,2,1,23,344,12,循环输出数列的值。

```java

public class Array {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

String s = arrayToString(arr);

System.out.println(arrayToString(arr));

}

public static String arrayToString(int[] arr) {

String result = "";

result += "[";

for (int i = 0; i < arr.length; i++) {

if (i == arr.length - 1) {

result += arr[i];

} else {

result += arr[i] + ", ";

}

}

result += "]"

return result;

}

}

```

数组的最值思想

举例:有一个数列:9,5,1,10,89,569,16,求出最大值和最小值。

```java

//求上述数列的最大值

public class Array {

public static void main(String[] args) {

int[] arr = {9,5,1,10,89,569,16};

System.out.println("最大值:" + getMaxValue(arr));

}

    public static int getMaxValue(int[] arr) {

// 1.假设第一个数为最大值

int max = arr[0];

// 2.遍历数组中的每一个元素

for (int i = 0; i < arr.length; i++) {

// 获取到每一个元素arr[i]

// 3.判断获取的元素是否比max大

if (arr[i] > max) {

// 4.设置arr[i]为最大值

max = arr[i];

}

}

return max;

}

}

```

```java

//求上述数列的最小值

public class Array {

public static void main(String[] args) {

int[] arr = {9,5,1,10,89,569,16};

System.out.println("最大值:" + getMinValue(arr));

}

    public static int getMinValue(int[] arr) {

// 1.假设第一个数为最小值

int min = arr[0];

// 2.遍历数组中的每一个元素

for (int i = 0; i < arr.length; i++) {

// 获取到每一个元素arr[i]

// 3.判断获取的元素是否比min大

if (arr[i]

// 4.设置arr[i]为最小值

min = arr[i];

}

}

return max;

}

}

```

数组倒置思想

举例:有一个数列:8,4,2,1,23,344,12,将数组倒置并输出。

```java

public class Array {

public static void main(String[] args) {

  int[] arr = {8,4,2,1,23,344,12};

  System.out.println("倒置前: " + arrays.toString(arr));

  reverseArray(arr);

  System.out.println("倒置后: " + arrays.toString(arr));

}

public static void reverseArray(int[] arr) {

  for (int i = 0; i < arr.length / 2; i++) {

int temp = 0;

temp = arr[i];

arr[i] = arr[arr.length - 1 - i];

arr[arr.length - 1 - i] = temp;

}

}

```

数组查找思想

举例:有一个数列:8,4,2,1,23,344,12,数组查找 猜数游戏:从键盘中任意输入一个数据,判断数列中是否包含此数。

```java

public class ArrayDemo06 {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

Scanner input = new Scanner(System.in);

    int num = input.nextInt();

    int index = baiscSearch(arr, num);

System.out.println(index != -1 ? "找到了该数" + arr[index] : "该数在数组中不存在");

}

public static int baiscSearch(int[] arr, int num) {

int index = -1;

for (int i = 0; i < arr.length; i++) {

if (arr[i] == num) {

index = i;

break;

}

}

return index;

}

}

```

数组排列思想(冒泡排列)

举例:有一个数列:8,4,2,1,23,344,12,数组排序。

```java

public class ArrayDemo06 {

public static void main(String[] args) {

int[] arr = {8,4,2,1,23,344,12};

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 temp = 0;

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

      }

}

}

}

}

```

你可能感兴趣的:(数组知识的回顾)