JAVA基础：六、集合框架

1.  集合框架  容器
    数组：长度是固定的。类型是固定的。
    集合：长度可变，可以放任何类型的对象

    1.ArrayList 集合：又名动态数组,可以容纳任意长度，任意类型的对象（不包括基本类型） 
 构造函数 ArrayList()
                 ArratList(int length)

 

 常用方法：add(obj),add(index,obj);
    size();
    isEmpty();
    get(index);
    set(index,obj);
    contains(obj); 判断是否包含对象o
    indexOf(obj);
    remove(obj),remove(index);
    clear();
   
    2.LinkedList集合：链表 ，类似与ArrayList，但存储方式不相同（顺序排放与链表结构排放）
  构造函数 ： LinkedList();
       LinkedList(int length); 
  常用方法：基本等同于ArrayList
 addFirst()

addLast()
getFirst()

getLast()
removeFirst()

removeLast();
   
   3.Vector：线程安全集合(选讲)
 
   4.集合中存放的都是引用：集合的每个元素并不代表就是对象，其实只是引用，指向对象的地址。

   5.集合的继承体系：
  Collection  ： 可以重复，无序集合
   List（ArrayList，LinkedList，Vector） :可以重复，有序集合
   Set （HashSet）：不能重复，无序集合
  Map： HashMap
    键(Set):不能重复，无序集合
    值（Collection）：可以重复，无序集合

   6.set类型的集合： HashSet
 主要方法： add(),remove(),size(),clear();
     contains(o) 判断是否包含对象o
 特点：不能添加重复对象。
 如何确定两个对象是否相同：除了equals方法返回为true,hashCode()方法返回值也必须相同，该返回值用来确定每个对象在set中的位置，只有相同才能保证会放到HashSet中的同一个位置。

   7.迭代器 Iterator
 Set集合没有索引，不能使用get访问，但所有Collection的子类都能通过迭代器进行循环访问每个元素。（参考上课代码）

   8.Map类型集合：HashMap
 1.与Collection集合不同，Map类型集合每个元素值都包含两个对象：键--值
 键在Map中不能有重复对象
 2.主要方法：
  put(key,value);
  size();
  remove(key),clear();
  containsKey(key) 判断是否包含键key
  containsValue(value)判断是否包含值value
  其中put方法若添加重复的键，则表示覆盖原来的键
 3.Map不存在索引，但同样可以实现循环访问：
  使用：keySet()或entrySet()
 
   9.Collections 集合工具类
 常用方法（静态）：sort（List） 给List类型的集合排序（元素必须包含CompareTo方法）
     reverse（List） 将List类型的集合反转
    Arrays 数组工具类（选讲）

   10.泛型:集合可以存储任何类型的数据，那能不能指定集合只能存储那种类型的数据呢？--泛型
 1.定义类时可以在类名后添加泛型。如MyClass<T> T 表示泛型参数，可以是任何类名.
    定义函数时，可以用T作为参数，则必须传递T所指代的类型为参数。
 2.泛型的应用
    A.如果MyClass为普通类，创建对象时可以为MyClass指定一个泛型。MyClass的函数中以泛型作为参数类型的，就必须传入指定的类型

   public class MyClass<T>{
       void fn(T o){
         }
   public static void main(String [] args){
     MyClass<String> mc1 =new MyClass<String>();
            mc1.fn("hello");
            MyClass<People> mc2 = new MyClass<People>();  
            mc2.fn(new People());
            ArrayList<People> arr = new ArrayList<People>();
            arr.add(new People()); //只能传入People对象
            HashMap<String,People> = new HashMap<String,People>();
          }
      }

  B.如果MyClass作为父类：抽象类或接口。在继承时，也可以传入泛型。
  则子类继承父类的含泛型的非抽象方法时，必须传入泛型指定的类型。
    非抽象的方法，重写时也必须按泛型指定的类型作为参数类型.
    
     如  父类

abstract class  MyClass<T>{
   public void fn(T o){
    ........
   }
   public void fm(T o);
         }
  子类
  class MyC extends MyClass<People>{
   public void fm(People o) { //重写父类泛型抽象方法
    ........
   }
   public static void main(String [] args){
     MyC c = new MyC();
     c.fn(new People());//继承父类泛型方法
   }
  }

    某个类实现Comparable接口时就是这种使用方式

 3.实际上，属性，方法的返回值都可以以泛型作为类型。
  4.当创建对象，或继承时不时用泛型，则类型都为Object；
12.Compareable接口：
当需要排序的集合或数组不是单纯的数字型时，通常可以使用Comparable，以简单的方式实现对象排序或自定义排序。
实例：

 

import java.util.Arrays;
public class ComparableUser implements Comparable {
 private String id;
 private int age;
 public ComparableUser(String id, int age) {
  this.id = id;
  this.age = age;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public int compareTo(Object o) {
  return this.age - ((ComparableUser) o).getAge();
 }
 /**
  * 测试方法
  */
 public static void main(String[] args) {
  ComparableUser[] users = new ComparableUser[] {
    new ComparableUser("u1001", 25),
    new ComparableUser("u1002", 20),
    new ComparableUser("u1003", 21) };
  Arrays.sort(users);
  for (int i = 0; i < users.length; i++) {
   ComparableUser user = users[i];
   System.out.println(user.getId() + " " + user.getAge());
  }
 }
}