Java(五)集合、排序

集合

能存储任意对象,长度是可以改变的。
数组和集合的区别
区别1：

• 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值。
• 集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象。

区别2：

• 数组长度是固定的,不能自动增长。
• 集合的长度的是可变的,可以根据元素的增加而增长。

集合的遍历
依次获取集合中的每一个元素。
迭代器
集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历) 。
原理：迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二。
第一规定了整个集合体系的遍历方式都是hasNext()和next()方法。
第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可 。

List的三个子类的特点

• ArrayList:
  底层数据结构是数组，查询快，增删慢。
  线程不安全，效率高。
  空间不足时，增加原来空间的50%。
• Vector:
  底层数据结构是数组，查询快，增删慢。
  线程安全，效率低。
  空间不足时，增加原来空间的一倍。
  Vector相对ArrayList查询慢(线程安全的)
  Vector相对LinkedList增删慢(数组结构)
• LinkedList:
  底层数据结构是链表，查询慢，增删快。
  线程不安全，效率高。

ArrayList和Vector的区别
Vector是线程安全的,效率低
ArrayList是线程不安全的,效率高
共同点:都是数组实现的
ArrayList和LinkedList的区别
ArrayList底层是数组结果,查询和修改快
LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
共同点:都是线程不安全的

HashMap有什么特点？

基于Map接口的实现，存储键值对，即Key-Value形式，再开发中经常被用作数据的封装，它还可以接收Null值，无序且非同步的。底层存储着Entry对象。
原理：
HashMap的底层存储着Entry对象，通过Hash算法计算对应Key的hash值存储对象，将K/Y传给put()方法时，它调用hashCode计算hash值，从而得到对应在Table中的位置，若已经存在元素，HashMap通过链表将产生的碰撞冲突的元素组织起来，当冲突的元素超过某个限制，则使用红黑树来替换链表，从而提高速度。

泛型

<>中放的必须是引用数据类型
注意事项：前后的泛型必须一致，或者后面的泛型可以省略不写。

• 泛型类
  把泛型定义在类上
  格式：public class 类名<泛型类型1,…>
  注意事项：泛型类型必须是引用类型
• 泛型方法
  把泛型定义在方法上
  格式：public <泛型类型> 返回类型 方法名<泛型类型 变量名>
• 泛型接口
  把泛型定义在接口上
  格式：public interface 接口名<泛型类型>
• 泛型通配符 < ? >
  任意类型，如果没有明确，那么就是Object以及任意的Java类了
  ? extends E —— 向下限定，E及其子类
  ? super E ——向上限定，E及其父类

排序

内部排序：数据记录在内存中进行排序。
外部排序：因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

1.直接插入排序

思想：将数组分为两部分，将后部分元素逐一与前部分元素比较，如果当前元素array[i]小，就替换。找到合理位置插入array[i]
要点：设立哨兵，作为临时存储和判断数组边界之用。
注意：如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序。

    public void insertSort(int[] a) {    
        for(int i=1;i//从头部第一个当做已经排好序的，把后面的一个一个的插到已经排好的列表中去。    
                int j;    
                int x=a[i];//x为待插入元素    
                for( j=i;  j>0 && x1];j--){//通过循环，逐个后移一位找到要插入的位置。    
                    a[j]=a[j-1];    
                }    
                a[j]=x;//插入    
        }    

    }     

2.希尔排序(缩小增量排序)

思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

public void insertSort(int[] a) {    
        for(int i=1;i//从头部第一个当做已经排好序的，把后面的一个一个的插到已经排好的列表中去。    
                int j;    
                int x=a[i];//x为待插入元素    
                for( j=i;  j>0 && x1];j--){//通过循环，逐个后移一位找到要插入的位置。    
                    a[j]=a[j-1];    
                }    
                a[j]=x;//插入    
        }    

    }  

3.简单选择排序

思想：在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

private void selectSort(int[] a) {  
        for(int i=0;iint k=i;//k存放最小值下标。每次循环最小值下标+1  
            for(int j=i+1;j//找到最小值下标  
                if(a[k]>a[j])  
                    k=j;  
            }  
            swap(a,k,i);//把最小值放到它该放的位置上  
        }  
    }  
     public  void swap(int[] data, int i, int j) {    
            if (i == j) {    
                return;    
            }    
            data[i] = data[i] + data[j];    
            data[j] = data[i] - data[j];    
            data[i] = data[i] - data[j];    
        }   

4.堆排序

树形选择排序，是对直接选择排序的有效改进。

5.冒泡排序

思想：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

void bubbleSort(int a[], int n){  
    for(int i =0 ; i< n-1; ++i) {  
        for(int j = 0; j < n-i-1; ++j) {  
            if(a[j] > a[j+1])  
            {  
                int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
            }  
        }  
    }  
}  

改进后的算法，使排序趟数几乎减少了一半：

void Bubble_2 ( int r[], int n){  
    int low = 0;   
    int high= n -1; //设置变量的初始值  
    int tmp,j;  
    while (low < high) {  
        for (j= low; j< high; ++j) //正向冒泡,找到最大者  
            if (r[j]> r[j+1]) {  
                tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
            }   
        --high;                 //修改high值, 前移一位  
        for ( j=high; j>low; --j) //反向冒泡,找到最小者  
            if (r[j]1]) {  
                tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;  
            }  
        ++low;                  //修改low值,后移一位  
    }   
}   

6.快速排序

思想：
1. 选择一个基准元素,通常选择第一个元素或者最后一个元素。
2. 通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
3. 此时基准元素在其排好序后的正确位置。
4. 然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

7.归并排序

思想：
将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

8.桶排序/基数排序

转载请提示出处：http://blog.csdn.net/hguisu/article/details/7776068