6月25日Java学习

对象是什么

是在程序运行时使用new关键字在堆区创建的一种数据结构

对象的数据结构一定不一样吗？

用同一个类的构造方法的对象是一样的

类和对象的关系

1.数量1对多

2.存储位置

    类-静止的时候存储在磁盘

        运行的时候加载到方法区

    对象-静止的时候没有对象

            运行时创建到堆区

面向对象三大特性

属性Property：指的是类的成员变量，非静态变量     

类的抽象：抽象是设计类的过程，根据现实世界物理或逻辑存在的某一事物进行抽象

                  1.抽象类的特征 - 用属性描述出来

                  2.抽象类的行为 - 用方法描述出来

第一特性：类的封装

        禁止把对象的属性暴露给外部访问，因为外部可能会赋非法值

1.使用private私有化属性

2.为属性添加setter和getter方法

setter：

1.方法名必然叫做setXXX，方法有参数，方法没有返回值

getter：

方法名必然叫做getXXX，方法没有参数，方法有返回值

3.在外部使用这样的语法修改对象的属性

指针.属性=值===> 指针.set属性(值)

在外部使用这样的语法读对象的属性

指针.属性 ===> 指针.get属性()

输入     输出

setter和getter方法

setter：设值器方法，用于外部对对象中的属性值进行写操作，有参数，没有返回值

getter：读值器方法，用于外部对对象中的属性进行读操作，没有参数，有返回值

一个标准的Java类

public class 类名 {

        // private 成员变量         核心

        // public 成员方法

        // public 构造方法

        // public setter设值器和getter读值器

}

1. 冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法描述

1.比较相邻的元素。如果第一个比第二个大，就交换它们两个；

2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

3.针对所有的元素重复以上的步骤，除了最后一个；

4.重复步骤1~3，直到排序完成。

代码实现

import java.util.Arrays;
import java.util.Random;

public class Bubble {
    public static void main(String[] args) {
        Random random = new Random();
        int[] arr =  random.ints(10,0,100).toArray();
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr){
        if(arr == null || arr.length <= 1){
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int assist = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = assist;
                }
            }
        }
    }
}

 

2. 简单选择排序（Selection Sort）

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

1.初始状态：无序区为R[1…n]，有序区为空；

2.第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；

3.n-1趟结束，数组有序化了。

 代码实现

import java.util.Arrays;
import java.util.Random;

public class Selection {
    public static void main(String[] args) {
        Random random = new Random();
        int[] arr = random.ints(10,0,100).toArray();
        selectionSort(arr);
        System.out.println(Arrays.toString(arr));

    }

    public static void selectionSort(int[] arr){
        if(arr == null || arr.length <= 1){
            return;
        }
        for (int i = 0; i < arr.length -1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]){
                        minIndex = j;
                }
            }
            if(i != minIndex){
                swap(arr,minIndex,i);
            }
        }
    }

    public static void swap(int[] arr,int a,int b){
        int text = arr[a];
        arr[a] = arr[b];
        arr[b] = text;
    }
}

3. 直接插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

1.从第一个元素开始，该元素可以认为已经被排序；

2.取出下一个元素，在已经排序的元素序列中从后向前扫描；

3.如果该元素（已排序）大于新元素，将该元素移到下一位置；

4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

5.将新元素插入到该位置后；

6.重复步骤2~5。

 

代码实现

import java.util.Arrays;
import java.util.Random;

public class Insertion {
    public static void main(String[] args) {
        Random random = new Random();
        int[] arr = random.ints(10,0,100).toArray();
        InsertionSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void InsertionSort(int[] arr ){
        if(arr == null || arr.length <=1){
            return;
        }
        int insertSum;
        for (int i = 1; i < arr.length; i++) {
            insertSum = arr[i];
            int j = i -1;
            while (j >= 0 && arr[j] > insertSum){
                arr[j+1] = arr[j];
                j--;
            }
            arr[j + 1] = insertSum;
        }


    }
}

 

6. 快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

1.从数列中挑出一个元素，称为 “基准”（pivot）；

2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

代码实现 

import java.util.Arrays;
import java.util.Random;

public class Quick {
    public static void main(String[] args) {
        Random random = new Random();
        int[] arr = random.ints(10,0,100).toArray();
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }


    public static void quickSort(int[] arr) {

        quickSort(arr, 0, arr.length - 1);

    }
    private static void quickSort(int[] arr, int left, int right) {
        if (arr == null || left >= right || arr.length <= 1) {
            return;
        }
        int mid = partition(arr, left, right);
        quickSort(arr, left, mid);
        quickSort(arr, mid + 1, right);
    }

    private static int partition(int[] arr, int left, int right) {
        int temp = arr[left];
        while (right > left) {
            while (temp <= arr[right] && left < right) {
                --right;
            }
            if (left < right) {
                arr[left] = arr[right];
                ++left;
            }
            while (temp >= arr[left] && left < right) {
                ++left;
            }
            if (left < right) {
                arr[right] = arr[left];
                --right;
            }
        }
        arr[left] = temp;
        return left;
    }
}