Java集合框架的一些了解和基本用法

        一、Collection接口
                 Collection是最基本的集合接口，定义了一组允许重复或者不重复的对象，主要需要了解它两大子类Set，List


   1、List接口
              继承自Collection接口，允许元素重复，元素是有序


2、ArrayList
              基于数组的List


       (1)   //创建ArrayList对象
      ArrayList<String> fruits = new ArrayList<String>();


           //添加元素
         fruits.add("苹果");
           fruits.add("香蕉");

          //获取链表长度
          int size = fruits.size();
          //访问内容（一一遍历出各个元素）
         for (int i = 0; i < size; i++) {
 String s = fruits.get(i);
  System.out.println(s);

    }

 

             （2）   移除内容

              使用remove(int index)表示按下标移除
              String removeItem = fruits.remove(2);


            使用remove(Object obj)表示按元素内容移除(首次出现的)
            fruits.remove("香蕉");


               （3）  修改内容

                    fruits.set(3, "梨子");

 

              （4） 检测是否包含


           //判断链表中是否包含某个元素
           boolean isHas = fruits.contains("葡萄");
            System.out.println(isHas);


                       检测是否为空

              boolean isEpt = ls.isEmpty();

                    清空内容

                 //清空链表内容
           ls.clear();


                   （5）  链表转为数组


                     //将链表转为数组
                         Integer[] ary = new Integer[ls.size()];
                         ls.toArray(ary);


                     //将数组转为链表

                     List<Integer> l = Arrays.asList(ary);

        3、方法使用的规律


你要拿什么东西（获取什么）那么这个方法方法要有返回值


不要给什么东西给他，那么方法必须有参数列表


方法属于对象，调用时使用对象来调用


  4、LinkedList
链式集合，跟ArrayList不一样，它基于链（头尾相连），特点增删速度快，查询速度慢。ArrayList查询快，增删慢。


LinkedList<String> list = new LinkedList<String>();
//添加到末尾
list.add("苹果");
// 添加到头部
list.addFirst("香蕉");
// 添加到尾部
list.addLast("梨子");


// 移除头部元素
String str = list.removeFirst();


removeLast(); 移除尾部元素


//读取头部元素，但不移除
String s2 = list.peek();


       5、Set接口
不允许重复，无序的


     （1）HashSet
允许有null元素，但是只有一个

HashSet<String> hs = new HashSet<String>();
//添加内容
hs.add("abc");
hs.add("123");


//移除内容
hs.remove("abc");


   （2）TreeSet
有自己的排序方式（红黑树结构排列）,元素不允许为null


TreeSet<String> ts = new TreeSet<String>();
ts.add("abc");
ts.add("123");


//获取大小
int size = ts.size();


     （3）Iterator接口
可以对collection进行迭代


对Set迭代

//从集合中产生迭代器
Iterator<String> it = ts.iterator();
while(it.hasNext()){  //判断有没有下一个节点
String s = it.next(); //读取下一个节点（指针向后移动）
System.out.println(s);
}


         6、 Map接口
Map接口用于维护键-值对的集合


特点：不允许重复的键


              （1）HashMap
基于哈希表（散列表）


//尖括号中第一个类型描述的键的类型，第一个是值的类型
HashMap<Character,String> hm = new HashMap<Character, String>();
//添加内容
hm.put('a', "苹果");
hm.put('b', "香蕉");
hm.put('c', "香蕉");


//获取内容
String str = hm.get('a');


//检测某个键是否存在
boolean isHasKey = hm.containsKey('d');


                （2）      遍历Map内容


//先将Map转为Set<Entry<K,V>>
Set<Entry<Character,String>> set = hm.entrySet();
//从Set上获取迭代器
Iterator<Entry<Character,String>> it = set.iterator();
//迭代每个键值对对象
while(it.hasNext()){
Entry<Character,String> entry = it.next();
//获取key
char key = entry.getKey();
//获取值
String value = entry.getValue();
System.out.println(key+":"+value);
}

 

   二、栈
Stack是一种后进先出的数据结构


Stack<String> s = new Stack<String>();
//将内容压入栈
s.push("A");
s.push("B");
s.push("C");


//读取栈顶内容，不移除
String str = s.peek();


//弹出栈顶元素
String str1 = s.pop();


//搜索元素和栈顶的距离
int index = s.search("A");


empty()检测栈是否为空

  三、Comparable接口
Comparable可以用于比较的实现，实现了Comparable接口的类可以通过重写它的compareTo方法来定义排序规则


public class Student implements Comparable<Student> {


private int id;


/**
* 当前学生对象跟其他学生对象比较的方法（实现Comparable接口重写） 
* 返回值：-1表示小了 1表示大了 0表示相等
*/
@Override
public int compareTo(Student other) {
if (id < other.id) {
return 1;
} else if (id > other.id) {
return -1;
}
return 0;
}


}
使用Collections.sort方法排序


//对集合进行排序(自然排序)
Collections.sort(stus);


             四、Comparator接口
可以对任意类型进行排列的比较器，排序时将此接口的实现传递给Collections.sort方法或者Arrays.sort方法即可


//按身份证好来排序(匿名内部类)
Collections.sort(ps, new Comparator<Person>(){


@Override
public int compare(Person o1, Person o2) {
if(o1.getId()<o2.getId()){
return -1;
}else if(o1.getId()>o2.getId()){
return 1;
}
return 0;
}
});


     注意：Comparator和Comparable的区别
Comparator位于java.util包下，而Comparable位于java.lang包下，前者可以在一个独立的来中实现比较，后者需要嵌入到自身类中。