1-7 数组与排序法

1 简介

数组是用来存储固定数量的同类型元素的一种数据结构，它是引用类型；

2 创建数组

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

示例：

int[] arr = {1,2,1,1,22,12};

数据类型[] 数组名 = new 数据类型[数组长度]

示例：

String[] arr = new String[5];

3 数组长度

数组对象的length变量，可以动态的计算出数组的长度

示例：

int len = arr.length;

4 访问数组元素

通过数组名加下标的形式访问数组元素：数组名[下标]

示例：

arr[0] = 12;

int a = arr[0];

5 遍历数组

1）for循环遍历数组

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

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

}

2）foreach循环遍历数组

//foreach循环 通过一个临时变量，接收每一次遍历到的值

for (int i : arr) {

System.out.println(i);

}

6 排序法

1）冒泡排序

/*

 * 冒泡排序法

 * 在要排序的一组数中，对当前还未排好序的范围内的全部数，自前而后对相邻的两个数

 * 依次进行比较和交换位置，让较大的数往后，较小的数往前（冒泡）。

 * 即，每当两个相邻的数比较后发现他们的排序与排序要求相反时，将他们交换位置

 */

 

int[] arr = {3,4,2,1,6,5,8,7};

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

for (int j = 1; j < arr.length-i; j++) {

if (arr[j-1] > arr[j]) {

int tar = arr[j];

arr[j] = arr[j-1];

arr[j-1] = tar;

}

}

}

2）选择排序

/*

 * 选择排序法

 * 在要排序的一组数中，选出最小的一个数与第一个位置的数交换；

 * 然后在剩下的数当中再找最小的数，与第二个位置的数交换；

 * 如此循环到倒数第二个数和最后一个数比较为止。

 */

 

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

//待确定的位置,记录当前最小的数的下标

int k = i;

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

if (arr[j] < arr[k]) {

k = j;

}

}

//交换两个数

int tar = arr[i];

arr[i] = arr[k];

arr[k] = tar;

}

1. 插入排序

/*

* 插入排序的工作方式：像抓扑克牌

* 开始时，我们的左手为空并且桌子上的牌面向下；

* 然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置（大牌在后，小牌在前）；

* 为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较。

*/

 

int[] b = {3,4,5,1,2};

for (int i = 0; i < b.length-1; i++) {

for (int j = i+1; j > 0; j--) {

if (b[j] < b[j-1]) {

int temp = b[j];

b[j] = b[j-1];

b[j-1] = temp;

}

}

}

7 Arrays工具类-java.util.Arrays

打印数组

Arrays.toString(arr);

数组赋值

Arrays.fill(arr, 0);//给数组所有元素都赋值为0

//fill(数组, 开始下标, 结束下标, 替换值)

//从开始下标（包括开始下标）到结束下标（不包括结束下标）范围内的所有元素 全部替换为3

Arrays.fill(arr, 1, 3, 3);

数组排序

Arrays.sort(arr3);//按照元素自然顺序排序

二分查找

//4 二分查找，前提：必须先给数组排好序

int index = Arrays.binarySearch(arr3, "b");

System.out.println(index);

复制数组（扩容）

int[] arr4 = Arrays.copyOf(arr2, 10);

比较数组

boolean tar = Arrays.equals(arr, arr2); //比较数组是否一样

8 多维数组

多维数组可以看成是数组的数组，即数组中的元素还是数组；

比如二维数组就可以看成是一个特殊的一维数组，其每一个元素都是一个一维数组。

 

创建二维数组

//创建二维数组的方式

int[][] arr = new int[2][3];

int[][] arr2 = { {1,2,3},{4,5,6},{7,8,9} };

//纵轴数组 就相当于 横轴数组的一个元素，所以纵轴数组长度不需要一样

int[][] arr3 = new int[2][];

arr3[0] = new int[3];

arr3[1] = new int[4];

遍历二维数组

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

for (int j = 0; j < arr2[i].length; j++) {

System.out.print(arr2[i][j] + ",");

}

System.out.println();

}

9 写的一些代码

数组

package d5;

import java.util.Arrays;

import java.util.Iterator;

/*

 * 数组

 * 定义：存储一组同类型的数据

 * 1 有顺序，下标从0开始

 */

public class ArrDemo {

public static void main(String[] args) {

//1 声明数组

int[] a1 = new int[5];//定义数组长度：数组中的元素个数

int[] a2 = {1,2,3};//定义元素

// int[] a3 = {1,2,3,};

// System.out.println(a3.length);

//非Java传统语法的写法

int a4[] = new int[3];

//2 获取数组长度，length变量

int len = a2.length;

/*

 * 数组获取长度length变量

 * 字符串获取长度length（）方法

 * 集合获取长度size（）方法

 */

//3 访问元素

// System.out.println(a2[1]);

//4 修改元素

a2[1] = 12;

// System.out.println(a2[1]);

//5 遍历数组

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

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

}

//6 二维数组：多维数组可以看成是数组的数组，即数组中的元素还是数组

int[][] b1 = new int[2][3];

int[][] b2 = {

{1,2},

{3,4},

{5,6},

};

System.out.println(b2[0].length);

//7 java.util.Arrays工具类

//7-1 打印数组

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

//7-2

//给数组所有元素都赋值为99

Arrays.fill(a1, 99);

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

/*

 * fill(arr,starIndex,endIndex,val)

 * 从startIndex下标开始，到endIndex结束，但不包括endIndex

 * 将范围内的数组元素重新赋值

 */

Arrays.fill(a1, 1,3,1);

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

//7-3 自然排序（数字从小到大，字符a-z）

int[] a5 = {3,1,2,5,4};

String[] a6 = {"d","a","b","e","f"};

Arrays.sort(a5);

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

//7-4 二分查找：返回被查找的数在数组中的下标

//二分查找的前提是先对数组进行自然排序

int res = Arrays.binarySearch(a5, 4);

System.out.println(res);

//复制数组（扩容）

int[] a7 = Arrays.copyOf(a2, 5);

System.out.println(a7.length);

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

String[] a8 = Arrays.copyOf(a6, 10);

System.out.println(a8.length);

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

//引用类型的默认值null

}

}

排序法

package d5;

import java.util.Arrays;

public class Arr2 {

public static void main(String[] args) {

//排序法

int[] arr = {3,4,2,1,5};

// mpSort(arr);

// selectSort(arr);

insertSort(arr);

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

}

//冒泡排序

public static void mpSort(int[] a) {

for (int i = 0; i < a.length-1; i++) {

for (int j = 0; j < a.length-1-i;j++) {

if (a[j]>a[j+1]) {

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

}

//选择排序

public static void selectSort(int[] a) {

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

int k = i;//k记录更小值的下标，初始值就是每次循环的第一个值的下标

for (int j = i+1; j < a.length; j++) {

if (a[k] > a[j]) {

k = j;

}

}

int temp = a[i];

a[i] = a[k];

a[k] = temp;

}

}

//插入排序

    public static void insertSort (int[] a) {

for (int i = 0; i < a.length-1; i++) {

for (int j = i+1; j > 0; j--) {

if (a[j] < a[j-1]) {

int temp = a[j];

a[j] = a[j-1];

a[j-1] = temp;

}

}

}

}

}