Java 数组排序以及一些基本知识

1. 排序

• 排序 是对数组施加的最常用的算法；
• 所谓排序，是指将数组元素按照从小到大或从大到小的顺序重新排列；
• 对于元素较多的数组，排序算法的优劣至关重要；
• 一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣；
• 常用的排序算法有：插入排序、冒泡排序、选择排序等。

1.1 选择排序

• 将数组中每个元素与第一个元素比较，如果这个元素小于第一个元素，则交换这两个元素
• 循环第 1 条规则，找出最小元素，放于第 1 个位置
• 经过 n-1 轮比较完成排序

//选择排序
    public static int[] sort(int a[]){
        for(int i = 0;i<a.length-1;i++){
            for(int j=i+1;j<a.length;j++) {
                if (a[i] > a[j]) {
                    int b = a[i];
                    a[i] = a[j];
                    a[j] = b;
                }
            }
        }
        System.out.println(Arrays.toString(a));
        return a;
    }

1.2 冒泡排序

• 比较相邻的元素，将小的放到前面。

//冒泡排序
    public static int[] sort1(int a[]){
        for(int i=0;i<a.length-1;i++){
            for(int j=0;j<a.length-i-1;j++){
                if (a[j] > a[j+1]) {
                    int b = a[j];
                    a[j] = a[j+1];
                    a[j+1] = b;
                }
            }
        }
        System.out.println(Arrays.toString(a));
        return a;
    }

1.3 插入排序

• 将数组分为两部分, 将后部分的第一个逐一与前部分每一个元素比较，在合理位置插入
• 插入排序算法效率要高于选择排序和冒泡排序

//插入排序
    public static int[] sort2(int a[]){
        int t,i,j;
        for(i=1;i<a.length;i++){
            t=a[i];
            for(j=i-1;j>=0;j--){
                if(t<a[i]){
                    a[j+1]=a[j];
                }else{
                    break;
                }
            }
            a[j+1]=t;
        }
        System.out.println(Arrays.toString(a));
        return a;
    }

2. 方法的定义

方法用于封装一个特定的功能；方法的五个要素：修饰词、返回值类型、方法名、参数列表、方法体；

关于方法参数的定义：

•	方法的参数是指：在调用时传递给方法，需要被方法处理的数据；
•	方法可有参数也可以没有参数，有参可使方法处理更加灵活；
•	在方法定义时，需要声明该方法所需要的参数变量；
•	在方法调用时，会将实际的参数值传递给方法的参数变量，必须保证传递参数的类型和个数符合方法的声明。
•	方法调用结束后可以返回一个数据，称之为返回值；
•	方法在声明时必须指定返回值的类型；
	-- 若方法不需要返回数据，将返回值类型声明为void。
	-- 若方法需要返回数据，将返回值类型声明为特定数据类型。
	

方法的简单运用：

import java.util.Arrays;

public class Demo01Text {
    public static void main(String[] args) {
        char[]arrChar={'h','e','l','l','o'};
        char[]guess={'h','i'};
        compare(arrChar,guess);
        System.out.println(Arrays.toString(arrChar));
        System.out.println(Arrays.toString(guess));
    }

    public static void compare(char[] answer,char[] guess){
        answer[0]='z';
        guess[1]='h';
    }
}

3. 对象的基本知识

3.1 什么是面向对象？

面向对象（oop，Object Oriented Programming）。一切皆对象，Java操作的基本单位就是对象。

3.2 类

类(类型): 所有同种对象共同的特征和行为, 抽象出来成为类。类不但定义了抽象数据类型的组成（成员变量），同时还定义了可以对该类型实施的操作（方法）。

对象: 符合类的实例化个体

类和对象的关系: 先定义或声明类, 然后再创建对象

3.3 类的使用方法

class: 类（类型）和int功能相似。
使用对象的步骤:

1.必须先有类，创建一个类。
class Student {
    成员变量 name age
    成员方法
}
2.才能在main方法中，创建Student对象。
    Student s = new Student();
    
3.有了对象, 对象包含了成员变量(name和age)和成员方法
    可以直接调用Student中的方法

3.4 局部变量和成员变量的区别

局部变量和成员变量的区别：

1.声明位置
    局部变量: 定义在方法中
    成员变量: 定义在类中
2.初始化
    局部变量: 使用前必须初始化，否则会报错
    成员变量: 可以初始化, 如果没有初始化, 会直接使用默认初始值
3.个数
    局部变量: 声明个数
    成员变量: 由对象决定, 有几个对象就有几个成员变量
4.内存中的位置
    第一次使用类[创建类的对象]之前, 会先将类进行加载
    局部变量: 方法栈中。方法结束后， 局部变量会消失。
    成员变量: 跟对象一起, 在堆中

3.5 方法重载

在Java语言中，允许多个方法的名称相同，但参数列表不同，称之为方法的重载（overload）。

参数列表不一样的情况: 个数不同\类型不同\顺序不同
例如：
  (int a)
  (double d)
  (int a, int b)
  (int b, int a) ×
  (int a, float b)
  (float b, int a)

package Overload;

public class Demo01MethodOverLoad {
    public static void main(String[] args) {
        Demo01MethodOverLoad demo1 = new Demo01MethodOverLoad();
        //构造方法的重载
        //调用方法:需要传递不同类型的参数
        demo1.hit(1);

        demo1.hit("伞");

        demo1.hit(2.0);
    }

    public static void hit(String 伞){
        System.out.println("打"+伞);
    }
    public static void hit(int 车){
        System.out.println("打开APP");
        System.out.println("打车");
    }
    public static void hit(double a){
        System.out.println("打麻糍");
    }
}

运行结果：

3.6 构造方法

构造方法是在类中定义的方法，不同于其他的方法，构造方法的定义有如下两个规则：
• 构造方法的名称必须与类名相同。
• 构造方法没有返回值，但也不能写void。

语法：
	[访问修饰符] 类名( ) {
	     	// 构造方法体
	}

Student(){

    }
    
Student(String name,int age,String grade,String remakes,Car car){
        this.name=name;        
        this.age=age;
        this.grade =grade;
        this.remakes=remakes;
        this.car=car;
    }

3.7 this

this关键字用在方法体中，用于指向调用该方法的当前对象；简单的说：哪个对象调用方法，this指的就是哪个对象。严格来讲在方法中需要通过this关键字指明当前对象。
注意：

   this可以调用自己的成员变量, 当成员变量和临时变量重名时, this不能省
   this也可以调用自己的成员方法, this可以省略
   this也可以调用自己的构造方法, this(参数), this不能省
   只能放在构造方法的第一行

3.8 引用类型数组

在Java中，数组属于引用数据类型；
数组对象在堆中存储，数组变量属于引用类型，存储数组对象的地址信息，指向数组对象。
数组的元素可以看成数组对象的成员变量（只不过类型全都相同）。

引用类型的数组的使用步骤:
     1.给数组初始化
        Student[] ss = new Student[5]; // 默认值都是null
     2.给数组元素初始化
        ss[0] = new Student();
        ss[1] = new Student();
        ...

若不给数组元素初始化，会出现空指针异常NullPointerException。

4. 方法、类和局部变量等的综合运用

Demo02Init.java

package oop;

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

        Student s= new Student();
        s.age = 21;
        s.name = "小明";
        s.grade = "Java班";
        s.remakes = "无";
        System.out.println(s.name);
        System.out.println(s.age);
        System.out.println(s.grade);
        System.out.println(s.remakes);
        System.out.println(s.car);

        System.out.println("--------------------");
        Student s1 = new Student("小明",21,"Java班","无",new Car("白色","大众",100000));
        s1.message();

        System.out.println("--------------------");
        Student s2 = new Student("小王",22,"计算机班","无",new Car("白色","宝马",900000));
        s2.message();
    }
}

Student.java

package oop;

/**
 * 学生实体类
 */
public class Student {
    //成员变量 ->可以不用初始化，有默认初始值
    //默认初始值：基本数据类型：0    引用数据类型：null
    String name;
    int age;
    String grade;
    String remakes;

    //表示类中的成员变量是Car类型
    Car car;

    //构造方法
    //目的：为了给成员变量初始化
    //特点：方法名和类名一致   没有返回值
    //构造方法可以重载；当类中没有构造方法时，会默认添加无参构造方法
    Student(){

    }
    Student(String name,int age,String grade,String remakes,Car car){
        //无参构造器
        this.name=name;         //this表示这个对象，
        this.age=age;
        this.grade =grade;
        this.remakes=remakes;
        this.car=car;
    }

    //成员方法
    void study(String subject,String name){
        //局部变量  需要初始化
        int a = 1;
        System.out.println(name+"正在学习："+subject);
    }

    void message(){
        System.out.println("学生姓名："+name);
        System.out.println("年龄："+age);
        System.out.println("班级："+grade);
        System.out.println("备注："+remakes);
        System.out.println("汽车颜色："+car.color);
        System.out.println("汽车品牌："+car.name);
        System.out.println("汽车价格："+car.price);
    }
}

Car

package oop;

public class Car {
    String color;
    String name;
    int price;

    Car(){

    }
    Car(String color,String name,int price){
        this.color=color;
        this.name=name;
        this.price=price;
    }
}

运行结果：