1 数组
1.1 概念
数组Array，标志是[ ]，用于存储多个相同类型数据的集合；
想要获取数组中的元素值，可以通过脚标（下标）来获取；
数组下标是从0开始的,下标的最大值是数组的长度减1；
1.2 创建数组
数组的创建方式一般分为动态初始化和静态初始化
动态初始化：
int[] a = new int[5];
只定义了类型与长度，现在只有默认值，没有定义明确的每一个位置上的值，后续使用中可以继续赋值；
静态初始化：
int[] b = new int[]{1,2,3,4,5};
int[] c = {1,2,3,4,5};
定义了类型，与每一个位置的值，后续已经无法再修改值；
package array;
/**
* 本类用于数组练习的创建
* @author Administrator
*
*/
public class testCareateArray {
public static void main(String[] args) {
//1.创建数组
//1.1 静态创建
char[] c1 = {'h','e','l','l','o'};
char[] c2 = new char[] {'h','e','l','l','o'};
// 第一种写法更简单，所以日常使用更频繁，但应认识第二种写法，俩种功能完全一致；
// 创建的时候已经知道了每一个元素的值
//1.2动态创建
char[] c3 = new char[5];
//在内存中开辟一块连续的内存空间，用来存放5个字符
//现在数组中没有具体的值，后续使用中可以给此数组赋值；
c3 [0]='h'; //给数组赋值第1个元素值
c3 [1]='e'; //给数组赋值第2个元素值
c3 [2]='l'; //给数组赋值第3个元素值
c3 [3]='l'; //给数组赋值第4个元素值
c3 [4]='0'; //给数组赋值第5个元素值
//注意数组下标从0开始
System.out.println(c3[1]);
System.out.println(c3[2]);
System.out.println(c3[3]);
//1.3 创建String类型的数组，存放数据“a”，“b”，“c”；
String[] s1 = {"a","b","c"};
String[] s2 = new String [] {"a","b","c"};
String[] s3 = new String[3];
s3[0] = "a"; //给s3数组的第1个元素赋值为"a";
s3[1] = "b"; //给s3数组的第2个元素赋值为"b";
s3[2] = "c"; //给s3数组的第3个元素赋值为"c";
// 1.4 打印创建好的数组
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
//打印结果为数组类型的保存地址
System.out.println(Arrays.toString(s3));
//打印结果为具体元素值
// 1.5 查看数组的长度--数组中存放元素的个数
System.out.println(c1.length);
System.out.println(s1.length);
}
}
1.2.1 创建数组过程分析
程序创建数组 int[] a = new int[5]; 时发生了什么?
- 在内存中开辟连续的空间,用来存放数据,长度是5
- 给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
- 数组完成初始化会分配一个唯一的地址值
- 把唯一的地址值交给引用类型的变量a去保存
注意：数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据
1.2.2 数组的查看方式
使用Arrays.toString(数组)方法，查看数组中的具体内容；
char类型的数组底层中做了处理，可以直接打印数组中的具体元素，除了char类型以外的数组想要查看数组中的具体元素，需要使用数组的工具类Arrays；
具体方式：Arrays.toString(数组名);
注意：Arrays使用时，需要导包
1.2.3 查看数组的长度–数组中存放元素的个数
System.out.println(c1.length);
直接打印输出定义数组的长度即可；注意数组一旦创建，长度不可改变，其在创建时，已经规定好了长度，如果想要增加或者删除数组中的元素，只能先创建一个新长度的数组，再将原数组的数据复制过去；
1.2.4 数组的缩容与扩容
使用Arrays.copyOf(数组，新的长度)方法对数组进行扩容；
数组的扩容：给数组扩大容量，新数组的长度>原数组的长度
数组的缩容：缩小数组的容量，新数组的长度<原数组的长度
package cn.tedu.array;
import java.util.Arrays;
/**本类用于练习数组的缩容与扩容*/
public class TestArraysCopyOf {
public static void main(String[] args) {
//1.创建数组
int[] from = {1,2,3,4,5};//数组一旦创建，长度不可改变
//2.1 数组的普通复制
/**copyOf()用于完成数组的复制，两个参数：
* 参数1：要复制哪个数组
* 参数2：新数组的长度*/
int[] to = Arrays.copyOf(from, 5);
System.out.println(Arrays.toString(to));
//2.2数组的扩容
/**扩容：给数组扩大容量，新数组的长度>原数组的长度
* 扩容思路：先创建对应长度的新数组，每个位置上都是默认值0
* 然后从原数组中将元素复制到新数组，没有被覆盖的元素还是默认值0*/
int[] to2 = Arrays.copyOf(from, 10);
System.out.println(Arrays.toString(to2));
//2.3数组的缩容
/**缩容：缩小数组的容量，新数组的长度<原数组的长度
* 缩容思路：先创建对应长度的新数组，每个位置上都是默认值0
* 然后从原数组中复制指定个数的元素到新数组中，类似于截取*/
int[] to3 = Arrays.copyOf(from, 3);
System.out.println(Arrays.toString(to3));
//2.4指定首尾截取原数组中的元素
/**copyOfRange()用于完成数组的截取，3个参数：
* 参数1：要截取哪个数组【原数组】
* 参数2：从原数组的哪个下标开始
* 参数3：到原数组的哪个下标结束
* 注意：截取的元素包含开始下标处的元素，不包含结束下标处的元素*/
int[] to4 = Arrays.copyOfRange(from, 2, 4);
System.out.println(Arrays.toString(to4));
}
}
1.2.5 指定首尾截取数组中的元素
使用Arrays.copyOfRange用于完成截取数组中的元素，共有3个参数：
参数1：要截取哪个数组【原数组】
参数2：从原数组的哪个下标开始
参数3：从原数组的哪个下标结束
int [] to4 = Arrays.copyOfRange(from, 2, 4);
System.out.println(Arrays.toString(to4));
注意数组下标是从0开始的；
1.3 数组的遍历
数组可以通过for循环进行遍历，从头到尾将数组的每个位置轮一遍
package array;
/**
* 本类用于进一步练习数组
* @author Administrator
*
*/
public class ArraysExct {
public static void main(String[] args) {
//1.创建一个数组，用来存放12个月的天数
int[] month = {31,28,31,30,31,30,31,31,30,31,30,31};
//数组的遍历
//2.通过for循环遍历数组
for (int i=0; i<=month.length-1; i++) {
System.out.println((i+1)+"月有"+month[i]+"天");
}
}
}
我们通过数组下标来操作数组中的元素：
month[0]代表数组的开始，
month[month.lenght-1]表示数组的结束，
变化情况为++
1.4 数组的排序
Arrays.sort(数组)可对数组进行排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高
对引用类型数组,使用的是优化后的合并排序算法；
package cn.tedu.array;
import java.util.Arrays;
/**本类用于测试数组的工具类Arrays*/
public class TestArraysSort {
public static void main(String[] args) {
//1.创建无序数组
int[] a = {21,96,75,23,25};
//底层使用的排序算法是进行优化后的快速排序算法
Arrays.sort(a);//对无序数组进行直接排序
System.out.println(Arrays.toString(a));
}
}
2 数组的练习
2.1 数组与方法的存数据，取数据
1.将上方代码常见一个m1方法，方便后续使用，用于从数组中取数据
2.创建一个动态数组，长度为10，放入方法m2中，用于从数组中存数据
package array;
import java.util.Arrays;
/**
* 本类用于进一步练习数组
* @author Administrator
*
*/
public class ArraysExct {
public static void main(String[] args) {
m1(); //用于从数组中取数据
m2(); //用于从数组中存数据
}
private static void m2() {
// 动态创建长度为10的数组
int[] a= new int [10];
//遍历数组，一次给数组的每一个位置上的元素赋值
//i代表的是数组的下标，从0开始，最大下标是数组的长度-1
for(int i=0; i<=a.length-1; i++){
// 根据每轮循环到的i，作为数组下标，操作数组对应位置上的元素
a[i] = i+4;
}
//循环结束后，说明数组的每个位置都经历了赋值（存数据）
System.out.println(Arrays.toString(a));
//[4,5,6,7,8,9,10,11,12]
}
private static void m1() {
// 创建方法
//1.创建一个数组，用来存放12个月的天数
int[] month = {31,28,31,30,31,30,31,31,30,31,30,31};
//数组的遍历
//2.通过for循环遍历数组
for (int i=0; i<=month.length-1; i++) {
System.out.println((i+1)+"月有"+month[i]+"天");
}
}
}
2.2 存入随机数据以及存入随机长度的数据
package day05;
import java.util.Arrays;
import java.util.Random;
public class ArraysExct2 {
public static void main(String[] args) {
m1(); //创建一个随机数组
m2(); //创建一个随机长度的数组
}
private static void m2() {
// 创建一个长度随机的数据
// int lenght = new Random().nextInt(10); 限定最多位数为10；
int lenght = new Random().nextInt(5)+5; //[0,5]---[5,10]
int[] a = new int[lenght]; //数组的长度是生成的随机长度lenght
//遍历数组，依次向数组中的的每个位置存入随机值
for (int i=0; i<=a.length-1; i++) {
a[i] = new Random().nextInt(100);
}
System.out.println(Arrays.toString(a));
}
private static void m1() {
//动态创建一个长度为10的数组
int[] a = new int[10];
//遍历数组，依次向数组中的每个位置存入随机值
for (int i=0; i<=a.length-1; i++) {
a[i] = new Random().nextInt(100);
}
//打印存入的数组
System.out.println(Arrays.toString(a));
}
}
长度与数值均可以随机存入；
3 二维数组的创立及遍历
3.1 概念
存放数组的数组，也就是说数组里存的还是数组的数据形式；
3.2 创造二位数组
int[][] a = {{3,5},{7,9},{1,2}};
–创建外部数组,长度是3
–给每个外部数组的位置创建内部数组,每个内部数组的长度是2
–给每个内部数组进行数据初始化
–二维数组生成唯一的地址值
–把地址值交给引用类型变量a来保存
3.3 遍历二维数组
for (int i = 0; i < a.length; i++) {//遍历外部数组
for (int j = 0; j < a[i].length; j++) {//遍历内部数组
System.out.println(a[i][j]);//依次打印二维数组中每个元素的值
}
}
package day05;
import java.util.Arrays;
/**本类用于打印二维数组中的数据*/
public class ArraysExct2 {
public static void main(String[] args) {
//1.创建二维数组
// 3 5
//a[0][0] a[0][1]
// 7 9
//[1][0] a[1][1]
// 1 2 3
//a[2][0] a[2][1] a[2][2]
int[][] a = {{3,5},{7,9},{1,2,3}};
//2.遍历二维数组
for (int i = 0; i < a.length; i++) {
// System.out.println(Arrays.toString(a[i]));
for (int j = 0; j < a[i].length; j++) {
//a[i][j]--根据外部数组的下标和内部数组的下标定位具体的元素
System.out.print(a[i][j]);
}
System.out.println();
}
}
}
4 冒泡排序
4.1 概念
冒泡排序（Bubble Sort），是计算机科学领域中较简单的一种排序算法。
它重复地走访需要进行排序的元素，依次比较两个相邻的元素，如果元素的顺序（如从大到小、首字母从A到Z）错误就把元素的位置互换。
走访元素是重复进行的,直到没有任何相邻位置上的元素需要交换位置，排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
4.2 排序思路
依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。
(1)第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。
(2)比较第2和第3个数，将小数 放在前面，大数放在后面。
…
(3)如此继续，知道比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成
(4)在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。
(5)在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较中，最后两个数是不参与比较的。
(6)依次类推，每一趟比较次数减少依次
4.3 冒泡排序实例
package day05;
import java.util.Arrays;
//本类用于实现冒泡排序
public class BubbleSort {
public static void main(String[] args) {
// 1.创建一个无序的数组
int[] a = {17,96,73,25,21};
//2.调用排序的方法进行排序
method(a);
}
private static void method(int[] a) {
// 需要使用嵌套for循环
// 从1开始，从a.length-1结束
for(int i=1; i<=a.length-1; i++) {//控制的是轮数，加入有n个数，最多比较n-1轮
System.out.println("第"+i+"轮");
//内层循环控制的是在这一轮中比较的次数;j代表的是数组的下标，我们要通过下标操作数组中的元素相邻比较
for(int j=0; j<a.length-i; j++) {//最大下标不是固定的，随着i的变化而变化，上一轮确定的最大值，不需要参与本轮的比较，所以i轮确定i个，要-i；
//3.相邻比较，位置不对就互换
if(a[j]>a[j+1]) {//如果前面的数大于后面的数，就交换俩个位置上的元素
int c;
c = a[j]; //将a[j]的值赋值给c
a[j]= a[j+1]; //将a[j+1]的值赋值给a[j]
a[j+1]=c; //将c的值赋值给a[j+1]
}
//System.out.println("排序完成后的数组为："+Arrays.toString(a)); 此处可以查看在每一轮结束后的效果
}
}
System.out.println("排序完成后的数组为："+Arrays.toString(a));
}
}
5 冒泡排序的优化
5.1 排序次数优化
前边代码中，其实已经有关于冒泡排序的优化：
因为前面几轮排序产生的最大值不需要参与后几轮的比较，执行过几轮就会产生几个值不需要参与比较 , i 轮产生 i 个值,所以需要 - i
for(int j=0; j<a.length-i; j++) {//最大下标不是固定的，随着i的变化而变化，上一轮确定的最大值，不需要参与本轮的比较，所以i轮确定i个，要-i；
5.2 信号灯思想
实际排序过程中，有时不一定全部执行完循环排序才成功；
排序过程中，只要数据还有交换的变化，那么数据就还在继续执行排序中；
反之，只要数据没有交换的变化，那么表示数据已经排序完成，不需要继续执行后续的循环，
2559
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
