排序

04数组

一、键盘输入

1、引入键盘类

import java.util.Scanner;

2、创建键盘对象

Scanner   scanner=new Scanner(System.in);

3、输入数据

4、获取输入的数据

//1、导包：引入键盘类
import java.util.Scanner;
​
public class ScannerDemo {
​
    public static void main(String[] args) {
​
//        2、创建键盘对象
        Scanner   scanner=new Scanner(System.in);
​
//      3、输入数据
//       4\使用变量接收保存
//        输入字符串
//        String  s1=scanner.next();
////        输入一行字符串
//        String  s2=scanner.nextLine();
//
////        输入int
//        int  i=scanner.nextInt();
////        输入double
//        double  d=scanner.nextDouble();
////        输入boolean
        boolean   bl=scanner.nextBoolean();
​
​
//        System.out.println(s1);
//        System.out.println(s2);
//        System.out.println(i);
//        System.out.println(d);
        System.out.println(bl);
​
    }
​
}

二、数据类型

1、基本数据类型

byte short int long

float double

char

boolean

2、引用数据类型

数组

类：String字符串，枚举

接口

三、数组

1、数组是什么？

数据类型角度：数组是一种引用数据类型。

容器角度：数组是用来保存一组数据的容器。

我们之前的变量基本上都是基本数据类型的，每个变量只能存储一个值。

2、数组的特点

（1）数组中的数据可以是任何类型。

（2）一组数据必须类型相同。

（3）数组的长度，固定不变。

3、数组的存储原理

 

数组是一种存储数据的数据结构。

数组创建时，需要先确定其长度。

然后根据长度来划分元素空间。

每个元素中可以放一条数据。

元素的表示：数组名[下标]

四、数组的使用

 

1、声明数组

创建一个数组类型的变量。

语法：

元素的类型[] 数组名；

强调：数组名其实就是变量名！！

//        1/声明数组：创建一个数组类型的变量
//       使用数组类型声明，表示该变量中存储的是一个数组对象（容器）
        String[]   names;
        int[]    ages;

2、创建数组

必须先确定长度！！！！

语法：

new 元素的类型[长度];

关键字new用来创建新对象。

//        2、创建数组：创建一个数组类型的对象（容器）
//        下标0-4
        names=new   String[5];

 

3、元素赋值

数组名[下标]=数据；

元素的下标范围：0~长度-1

//        3、赋值
        names[0]="张三";
        names[1]="李四";
        names[2]="王五";
        names[3]="马六";
        names[4]="路人甲";

 

4、元素使用

还是通过 数组名[下标] 找到元素来取数据

//        4\使用数据
        System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
        System.out.println(names[3]);
        System.out.println(names[4]);

5、数组的遍历

获取数组的长度：数组名.length

for(int i=0;i<数据名.length;i++){

System.out.println(数据名[i]);

}

//        5、数组的遍历
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }

五、数组元素的缺省值

1、基本类型

byte short int long 0

float double 0.0

char 单个空白字符

boolean false

2、引用类型

所有引用类型的元素缺省值全是null

        int[]   a;
        double[]   b;
        char[]   c;
        boolean[]   d;
        String[]    s;


//        系统创建数组对象时，会给每个元素放一个缺省值
        a=new  int[4];
        b=new double[4];
        c=new  char[4];
        d=new  boolean[4];
        s=new String[4];

        System.out.println(a[0]);
        System.out.println(b[0]);
        System.out.println(c[0]);
        System.out.println(d[0]);
        System.out.println(s[0]);

六、数组下标越界

1、下标的范围

始终是从0开始，一直到（长度-1）

2、越界

public class ArrayDemo03 {
    public static void main(String[] args) {

        int[]  ages=new  int[5];
        ages[5]=5;
        System.out.println(ages[9]);

    }
}

运行时错误提示：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at ArrayDemo03.main(ArrayDemo03.java:5)

七、空指针问题

null是一个引用类型的数据，可以是任何引用类型。

没有对象的地址。

int[]   a=null;
System.out.println(a[0]);

运行时错误提示：

Exception in thread "main" java.lang.NullPointerException	
	at ArrayDemo04.main(ArrayDemo04.java:5)

没有new 就没有对象。

没有创建数组对象。

没有数组对象，就没有元素，没有元素就没有数据。

八、简写形式

       int[]  a;        
       a=new  int[3];        
       a[0]=0;        
       a[1]=1;        
       a[2]=2;  
       
       int[]   a2=new  int[3];        
       a2[0]=0;        
       a2[1]=1;        
       a2[2]=2;   
       
       int[]   a3=new   int[]{0,1,2};        
       
       int[]   a4={0,1,2};

九、二维数组

1、二维数组

Java数组的本质，全是一维数组。

一个数组元素中又是一个数组，这样的数组我们习惯上喜欢叫二维数组。

 

2、使用

（1）声明数组

语法：

内部元素的类型[][]    数组名;
内部元素的类型    数组名[][];
内部元素的类型[]    数组名[];

案例：

//        二位数组的声明
        int[]   a;
        int[][]  aa;

（2）创建数组对象

语法：

new   内部数组元素类型[外部数组长度][内部数组长度]

案例：

//        创建二维数组
        a=new  int[3];
        aa=new  int[3][4];

（3）元素赋值

元素：

数组名[外部数组下标][内部数组下标]

//        元素赋值
        aa[0][0]=100;
        aa[0][1]=101;
        aa[0][2]=102;
        aa[0][3]=103;

        aa[1][0]=110;
        aa[1][1]=111;
        aa[1][2]=112;
        aa[1][3]=113;

        aa[2][0]=120;
        aa[2][1]=121;
        aa[2][2]=122;
        aa[2][3]=123;

（4）遍历

//        遍历
//        aa.length=3
//        遍历外围数组
        for (int i = 0; i < aa.length; i++) {
//            遍历内部数组 aa[i]
            for (int j = 0; j < aa[i].length; j++) {
                System.out.println(aa[i][j]);
            }
        }

3、简写

//        简写
        int[][]   bb={ {100,101,102,103},{110,111,112,113},{120,121,122,123} };

十、排序

1、排序

按照某种规则，重新排列。

常见的规则：大小、时间、热度==。

2、排序算法

实现排列的方法，我们叫排序算法。

常见的：

冒泡排序

选择排序

快速排序

插入排序

哈希排序

堆排序

桶排序

归并排序

==

性能：

（1）时间复杂度

（2）空间复杂度

（3）稳定性

3、冒泡排序

相邻两个数据进行比较，不符合规则交换位置。

 

总结规律：

n个数使用冒泡排序。

需要排n-1遍。

每一遍需要比较n-i次 （i表示第几遍，从1开始） 。

每一次都是从第一个开始比。

代码实现：

 int[]   a={5,4,6,3,7,2,1};
​
//        由小到大，重新排列
​
//        排n-1遍
        for (int i = 1; i < a.length; i++) {
            //每一遍：比较n-i次
            //每一遍都是从0开始
            for (int j = 0; j < a.length-i; j++) {
                //每一次比较：相邻比较
                if(a[j] > a[j+1]){
                    //不满足，交换位置
                    int  temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
​
​
//        检查一下
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }