【狂神说Java】学习笔记14：数组
【狂神说Java】学习笔记14：数组
[01] 数组概述
[02] 数组声明创建
[03] 数组使用
[04] 多维数组
[05] Arrays类
[06] 稀疏数组
--------------------------------------------------------------------
数组的课程内容
[01] 数组概述
数组：相同类型数据的有序集合。比如{1,2,3,4}这就是数组， 通过下标来访问a[0]=1;
[02] 数组声明创建
package Chapter6_Array;
public class Demo01 {
// 变量类型 变量的名 = 变量的值
public static void main(String[] args) {
int[] nums =new int[10]; //声明数组并且在里面存放10个int类型的数字。
// 给每个数组元素赋值。
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
nums[5]=6;
nums[6]=7;
nums[7]=8;
nums[8]=9;
nums[9]=10;
// 应用1.输出数组的某一个值
System.out.println(nums[4]);
// 应用2.计算所有元素之和
int sum=0;
for(int i=0;i< nums.length;i++){
sum =sum + nums[i];
}
System.out.println(sum);
}
}
---------------------------------------------------
5
55
如果一共9个数组，你取到第十个的话，就会遇到下标越界的问题。（ArrayIndexOutOfBoundsException）
内存分析
数组的三种初始化
1.静态初始化
2.动态初始化
3.数组的默认初始化
package Chapter6_Array;
public class Demo02 {
/* 数组的三种初始化
1.静态初始化
2.动态初始化
3.数组的默认初始化
*/
public static void main(String[] args) {
// 1.静态初始化:创建加赋值
int[] a={1,2,3,4,5,6,7,8};
// 2.动态初始化
int[] b = new int[10];
b[0]=10;
// 3.默认初始化
// 在2的基础上，输出b[1]时显示为=0；
// 但是如果赋值b[1]=20；再输出的话就会有相应的20.实现了默认初始化。
}
}
数组四个基本特点
1.长达确定不可改变，
2.同一数组内的元素必须是相同类型。
3.数组的元素可以是任何类型。
4.数组内每个元素相当于对象的成员变量。
只要使用new关键词，声明的东西都是在堆中的，数组对象本身就是在堆中。
数组边界
下标是以[0]开始的，这个必须注意。
[03] 数组使用
基础训练
打印数组的元素，计算元素之和，查找数组内最大值。
package Chapter6_Array;
public class Demo03 {
public static void main(String[] args) {
//
int[] arrays={1,2,3,4,5};
//实行1：打印数组的所有元素。
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
// 实现2：计算所有元素的和
int sum=0;
for (int i = 0; i < arrays.length; i++) {
sum += arrays[i];
}
System.out.println("sum=" +sum);
// 实现3：查找最大元素
int max=arrays[0];
for (int i = 1; i < arrays.length; i++) {
if (arrays[i]>max){
max =arrays[i];
}
}
System.out.println("max="+max);
}
}
-----------------------------------------
1
2
3
4
5
sum=15
max=5
增强for循环写法。
新建方法并调用实现数组元素输出。
package Chapter6_Array;
public class Demo05 {
public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
printArray(arrays);
}
// 新建方法，然后通过调用方法来实现打印数组元素。
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
}
--------------------------------
1 2 3 4 5
★★★反转数组
让arrays数组的值12345变成54321并交给新的数组reverse
有点绕不好理解，但是是个很好的入门程序。里面有方法的创建，调用和数组的使用。
package Chapter6_Array;
public class Demo06 {
public static void main(String[] args) {
// ***反转数组，让arrays数组的值12345变成54321并交给新的数组reverse。
int[] arrays={1,2,3,4,5};
int[] reverse=reverse(arrays);
printArray(reverse); //使用打印方法来输出reverse
}
// 反转数组
public static int[] reverse(int[] arrays){
int[] result =new int[arrays.length]; //新建一个result的数组，大小就是arrays.length的长度。
// 反转操作,在一个for循环里定义两个for循环的内容。
for (int i = 0,j= result.length-1; i < arrays.length; i++,j--) {
//result[]=arrays[i]; //让arrays[i]的变量等于result数组的某个元素
result[j]=arrays[i]; //array[0]进来之后把值赋予result[]数组的最后一个元素。
}
return result;
}
// 打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
}
--------------------
5 4 3 2 1
[04] 多维数组
一组数组里某元素里又可拓展成为数组。
**多维数组应用 **
package Chapter6_Array;
import java.sql.SQLOutput;
public class Demo07 {
public static void main(String[] args) {
//嵌套数组
/* 等于是4个数组
1,2 array[0]
2,3 array[1]
3,4 array[2]
4,5 array[3]
*/
int[][] array={{1,2},{2,3},{3,4},{4,5}};
//打印整个数组的话要调用打印数组方法
printArray(array[0]); //输出1 2
//打印数组内的某个元素的话直接输出即可
System.out.println(array[0][1]); //输出1
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
}
-----
1 2 1
** [05] Arrays类 **
打印数组
package Chapter6_Array;
import java.util.Arrays;
public class Demo08 {
// 打印数组里的元素。
public static void main(String[] args) {
int[] a={1,2,3,4,3131,1231231453,231123,455,22,1112};
System.out.println(a); //输出的结果是哈希code [I@c7ca48e7
System.out.println(Arrays.toString(a)); //静态类Arrays有很多方法，使用toString()便可。
//执行printArray方法，一样可以输出上面的结果。
printArray(a);
}
// 重复造轮子：虽然封装好了tostring()的方法，但是自己写方法打出来a数组的元素如下。
public static void printArray(int[] a){
for (int i = 0; i < a.length; i++) {
if(i == 0){
System.out.print("[");
}if (i ==a.length-1){
System.out.print(a[i]+"]"); //此时输出 print("]") 就是错，而是 a[i]+"]"
}else{
System.out.print(a[i]+", ");
}
}
}
}
----------------
[I@ea0d0326
[1, 2, 3, 4, 3131, 1231231453, 231123, 455, 22, 1112]
[1, 2, 3, 4, 3131, 1231231453, 231123, 455, 22, 1112]
数组排序sort 和数组的填充
package Chapter6_Array;
import java.util.Arrays;
public class Demo09 {
// 数组排序sort 和数组的填充
public static void main(String[] args) {
int[] a={1,2,3,4,3131,1231231453,231123,455,22,1112};
Arrays.sort(a); //对数组进行排序并进行排序输出，升序。
System.out.println(Arrays.toString(a));
// 令a数组的2到4下标的元素被20填充。
// 输入方法，fill(a,2,4,20),自动填充相符的内容。md却不显示...
Arrays.fill(a,2,4,20);
System.out.println(Arrays.toString(a));
}
}
----------------------
[1, 2, 3, 4, 22, 455, 1112, 3131, 231123, 1231231453]
[1, 2, 20, 20, 22, 455, 1112, 3131, 231123, 1231231453]
冒泡排序
冒泡排序 最基本方法
package Chapter6_Array;
import java.util.Arrays;
/*
冒泡排序
1.比较相邻两个元素的大小，如果第一个比第二个大吗，，就交换位置。
2.每一次比较，都会产生最大，最小的数字
3.下一轮可以减少一次排序。
4.依次排序，直到结束。
*/
public class Demo10 {
public static void main(String[] args) {
int[] a = {1,8,4,6,2,3,9,0,5,7}; // 一段无序的数组a。
int[] sort = sort(a); //定义一个sort数组，并通过sort()方法，把返回值拿到放到sort里。
//输出sort数组： Arrays静态类.toString(数组名)
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array){
//临时变量
int temp = 0;
//外层循环，判断走多少次，
for (int i = 0; i < array.length -1; i++) {
//内存循环。判断两个数，如果第一个数[j]比第二个数[j+1]大则交换位置。
for (int j = 0; j < array.length -1-i; j++) {
if (array[j]>array[j+1]){
//用临时变量当作暂时存储值，并交换两元素的值。
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
// 传进来的数组，经过一系列交换再return返回出去。并把 声明里的void类型改为int[]类型来接收。
return array;
}
}
----------------------
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
冒泡排序 优化1
package Chapter6_Array;
import java.util.Arrays;
/*
冒泡排序 优化版1：减少没有意义的比较
如果已经排好序了，就没有必要再次排序，直接可以跳过
*/
public class Demo11 {
public static void main(String[] args) {
int[] a = {1,8,4,6,2,3,9,0,5,7};
int[] sort = sort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array){
int temp = 0;
//外层循环，判断走多少次，
for (int i = 0; i < array.length -1; i++) {
boolean flag = false; //通过flag标识减少没必要的比较。
//内存循环。判断两个数，如果第一个数[j]比第二个数[j+1]大则交换位置。
for (int j = 0; j < array.length -1-i; j++) {
if (array[j]>array[j+1]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true; //循环完之后让flag为true。跳过再次比较。
}
}
//如果压根没有进循环，则说明无需排序，直接跳出。
if(flag == false){
break;
}
}
return array;
}
}
---------
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[06] 稀疏数组
稀疏数组是一组数据结构，
减少无意义的0的数据，来减少内存存储的压力。
只计算非0的数据，然后按照行列来记录下来。行列都是从0开始计算数起。如下：
[0]代表共6行，7列，8个值。22在第0行，第3列，因此是[1] 0 3 22
原始数组→稀疏数组→还原为原始数组
package Chapter6_Array;
public class Demo12 {
/*
稀疏数组应用
*/
public static void main(String[] args) {
// 创建一个2为数组。0代表没有棋子，1代表黑棋，2代表白棋。
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
// 1.输出原始数组。
System.out.println("输出原始数组：");
for (int[] ints:array1){
for (int anInt:ints){
System.out.print(anInt + "\t");
}
System.out.println();
}
System.out.println("========== 换格式打印稀疏数组 =========");
// 转换为稀疏数组来保存。
// 获取有效值的个数
int sum=0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j] !=0 ){
sum++;
}
}
}
System.out.println("有效值的个数：" + sum);
// 2.创建一个稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
// 遍历二维数组，将非0的值存储在稀疏数组内
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1.length; j++) {
// 有数组元素非0的情况下，记录下。
if(array1[i][j] !=0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
// 输出稀疏数组。
System.out.println("输出稀疏数组");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0] + "\t"
+array2[i][1]+ "\t"
+array2[i][2]+ "\t");
}
System.out.println("=====================================");
System.out.println("还原原数组");
//1.首先读取稀疏数组,有array2[0][0]行，array2[0][1]列
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原
for (int i = 1; i < array2.length; i++) {
//取出所有的值，新的array3[第0列值][第1列值]=array2[]
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//3.打印
System.out.println("输出还原数组");
for (int[] ints:array3){
for (int anInt:ints){
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}
----------------------------------------------------------------
输出原始数组：
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
========== 换格式打印稀疏数组 =========
有效值的个数：2
输出稀疏数组
11 11 2
1 2 1
2 3 2
=====================================
还原原数组
输出还原数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
