数组

数组概述

数组是用来存储一组相同类型数据的数据结构

数组变量属于引用数据类型

数组中的元素可以是任何数据类型

(基本类型和引用类型)

数组被创建好之后，它的大小是不能改变的，但是数组中的各个元素是可以被改变的

数组元素的引用

数组在定义并为之分配空间后，才可以引用数组中的每个元素

数组元素的引用方式：arrayName[index]

 index 为数组元素下标(索引)

数组元素下标从0开始;

长度为n的数组，下标取值范围：0 ~ n-1；

 

每个数组都有一个属性length指明它的长度，例如：

arr.length 可获取数组arr的长度；

 

元素的索引必须小于数组的长度,否则会产生数组越界异常

增强for循环

缺陷：

遍历数组或集合时无法访问索引(下标)值

用途：

只适合遍历显示数组或集合中元素的内容。

冒泡排序

原理：

比较两个相邻的元素，将值大的元素交换至右端

 

public static void bubbleSort(int[] a) {

    int n = a.length;

    //总共进行n-1轮的比较

    for (int i = 1; i < n; i++) {

        for (int j = 1; j < n ; j++) {

            if (a[j-1] > a[j]) {//交换

                int temp = a[j-1];

                a[j-1] = a[j];

                a[j] = temp;

            }}}}

选择排序

原理：每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕

public static void selectionSort(int[] a) {        

    for(int i = 0; i < a.length - 1; i++) {// 做第i趟排序

        int k = i;

        for(int j = k + 1; j < a.length; j++){// 选最小的记录

            if(a[j] < a[k]){

                k = j; //记下目前找到的最小值所在的位置

            } }

        if(i != k){  //交换a[i]和a[k]

            int temp = a[i];

            a[i] = a[k];

            a[k] = temp;

        }}}

插入排序

从数组的第一个元素a[0]开始，将其后一个元素a[1]插入到a[0]的前面或者后面，接着继续这一过程。每次都是将a[i]插入到已经排序好的a[0]~a[i-1]中合适的位置

public static void insertSort(int[] a) {

    for (int i = 1; i < a.length; i++) {

        for (int j = i; j > 0; j--) {

            if (a[j] < a[j - 1]) {

                int temp = a[j];

                a[j] = a[j - 1];

                a[j - 1] = temp;

            } else {

                break;

            } }}}

顺序查找

从第一个元素开始顺序比较查找。

public static int search(int[] a, int num) {        

    for(int i = 0; i < a.length; i++) {

        if(a[i] == num){

            return i;

        }

    }

    return -1;

}

 

二分查找

    int low = 0;                               // 起点

    int upper = a.length - 1;               // 终点

    while (low <= upper) {

        int mid = (low + upper) / 2;     // 中间点

        if (a[mid] < num) {                   // 中间点的值小于要查找的值

            low = mid + 1;                     // 更改查找的起点为中间点位置后一位

        } else if (a[mid] > num) {         // 中间点的值大于要查找的值

            upper = mid - 1;                  // 更改查找的终点为中间点位置前一位

        } else {                               // 中间点的值等于要查找的值

            return mid;                       // 返回该位置

        }

    }

    return -1;

}

饿汉式

饿汉式的特点是一开始就加载了，如果说懒汉式是“时间换空间”，那么饿汉式就是“空间换时间”，因为一开始就创建了实例，所以每次用到的之后直接返回就好了。
public class Singleton{
private static Singleton singleton = new Singleton ();
private Singleton (){}
 public Singleton getInstance(){return singletion;}
} 

懒汉式:

懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的

时候才会加载。。。。。。

public class Singleton{
private static Singleton singleton = null;
public static synchronized synchronized getInstance(){
                 if(singleton==null){
                     singleton = new Singleton();
                 }
                return singleton;
            }
       }