java------集合

list集合

 

ArrayList
List 接口的大小可变数组的实现，即长度可变的数组

ArrayList集合对象的创建：

ArrayList  list =new ArrayList ();

 

ArrayList方法

添加对象：

boolean add(E e) ----将指定的元素添加到此列表的尾部

void add(int index, E element) -----将指定的元素插入此列表中的指定位置

boolean addAll(Collection<? extends E> c)  ---将该 collection 中的所有元素添加到此列表的尾部

boolean addAll(int index, Collection<? extends E> c) ----从指定的位置开始，将指定 collection 中的所有元素插入到此列表中

 

删除对象

void clear() -----移除此列表中的所有元素

E remove(int index) -----移除此列表中指定位置上的元素

boolean remove(Object o) -----移除此列表中首次出现的指定元素（如果存在）

protected  void removeRange(int fromIndex, int toIndex)  -----移除 fromIndex（包括）和 toIndex（不包括）之间的所有元素

public boolean removeAll(Collection<?> c)-----删除和指定集合中所有相同的元素

public boolean retainAll(Collection<?> c)-----删除和指定集合中所有不相同的元素

 

替换对象

E set(int index, E element) -----用指定的元素替代此列表中指定位置上的元素

 

返回ArrayList的一个副本

Object clone()

 

查集合长度

int size()  -----返回此列表中的元素数

 

调整实例容量

void trimToSize() -----将此 ArrayList 实例的容量调整为列表的当前大小

 

判断是否包含元素

boolean contains(Object o) 

public boolean containsAll(Collection<?> c)-----包含指定 collection 中的所有元素

 

根据下标查元素

 E get(int index) -----返回此列表中指定位置上的元素

 

根据元素查下标

 int indexOf(Object o)  -----返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1

int lastIndexOf(Object o) -----返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1

 

判断集合是否为空

 boolean isEmpty()

 

比较ArrayList

public boolean equals(Object o)-----仅当指定的对象也是一个列表,两列表大小相同，所有元素一样才为true

 

ArrayList------>数组

Object[] toArray()-----按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组

<T> T[] toArray(T[] a)-----按适当顺序（从第一个到最后一个元素）返回数组的运行时类型所有元素

 

获取集合迭代器

public Iterator<E> iterator() -----返回以恰当顺序在此列表的元素上进行迭代的迭代器

public ListIterator<E> listIterator()-----返回此列表元素的列表迭代器（按适当顺序）

public ListIterator<E> listIterator(int index)-----返回从列表的指定位置开始next的列表迭代器

 

ArrayList集合的字符串表示

public String toString()

通过 String.valueOf(Object) 可以将元素转换成字符串

 

集合的反转

Collections.reverse(list);反转排序，先输出列表最后一个元素

 

集合(列表集合) / 数组的排序

方法一： 

1、排序的元素类必须实现java.lang.Comparable接口：public interface Comparable<T>

此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法

2、对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

例子：

public class User {
  private String id;
  private int age;
        get\set方法略

}

实现 User集合的按年龄排序

public class User implements Comparable<User>{
  private String id;
  private int age;
        get\set方法略

  public int compareTo(Object o) {              //实现Comparable 接口的排序方法
   // return this.age - ((User) o).getAge();                               //对int类型属性排序

    return this.getName().compareTo(((User) o).getName());//对String属性排序
  }

}

 

ArrayList<User> list=new ArrayList<User>();

list .add(user);

Collections.sort(list);                                             //集合元素升序排序

Collections.sort(list, Collections.reverseOrder());//集合元素降序排列

User[] users = new User[] { new User("a", 30), new User("b", 20) };

Arrays.sort(users);                                              //数组排序

 

方法二：

1、实现一个java.util.Comparator接口

2、

public class User implements Comparator<Person >{

  public int compare(Person o1, Person o2) {
    return o1.getAge() - o2.getAge();
  }

}

 

ArrayList<User> list=new ArrayList<User>();

list .add(user);

Comparator<Person> ascComparator = new User();   //创建升序对象

Collections.sort(list, ascComparator);// 利用Collections类静态工具方法对集合List进行排序

 

Comparator<Person> descComparator = Collections .reverseOrder(ascComparator);// 从升序排序对象产生一个反转(降序)的排序对象

Collections.sort(list, descComparator);

 

 常用方法：

 集合复制，java默认的复制规则是浅层复制(即只复制了集合里的对象引用，并没有复制集合里对象的本身)
集合复制有2种方式：
 1、clone()-----是Object定义的 //只能复制本类型
  ArrayList<Foo>  list = new ArrayList<Foo>();
  ArrayList<Foo>  list = (ArrayList<Foo>) list.clone();

 2、复制构造器   //可在不同类型的集合间复制（继承自Map的集合同继承自Collection的集合不能相互复制，结构不同）
  Map    map  = new HashMap();  --------Map   map2  = new HashMap(map);
  
  List  list  = new ArrayList();--------List  list2 = new LinkedList(list);
           --------LinkedList<Foo> list2 = new LinkedList<Foo>(list);
           --------HashSet<Foo>    set   = new HashSet<Foo>(list);
  
集合增删改查操作：
ArrayList list = new ArrayList();
list.add("tom");
list.add(new Date());

list.remove("tom");//按对象删除，默认调用equals()比较 （remove()方法是有返回值的，返回被删除的元素）
list.remove(0);    //按序号删除

list.set(0,"king");//将第一个对象修改为“king”

int  i=list.indexOf("tom");//查询"tom"元素的下标

集合和集合之间的操作：（和、交、差）
list.addAll(list2); //将两集合合并

list.removeAll(list2); //将list中和list2相同的元素删除

list.retainAll(list2); //将list中和list2相同的元素保留

list.isEmpty();  //判断是否为空集  （空集和null不一样）

 

数组------〉List
String[]  names = {"A","B","C"};

List  list = Arrays.asList(names);  //list是只读list，不能增删操作

      list = new ArrayList(list);   //复制为全功能list，可以增删读操作

Set   set  = new HashSet(list);     //

集合-------〉数组

集合转为Object[]:
Object[]  ary = list.toArray();

集合转为指定类型数组：
String[]  ary = (String[])list.toArray(new String[]{});

 

集合迭代：
是一种遍历算法

1)  java 使用 Iterator 接口描述了迭代模式操作Iterator 中的方法，与门为 while 循环设计
2)  Iterator 的实例可以从集合对象获得，是这个集合的一个元素序列视图，默认包含一个操作游标（在第一个元素之前）
?  hasNext()方法，可以检查游标是否有下一个元素
?  next()  方法，移动游标到下一个元素，并丏返回这个元素引用使用 while 循环配合这个两个方法,  可以迭代处理集合的所有元素
3)  迭代时可以使用迭代器 remove()  方法删除刚刚迭代的元素在迭代过程中
?  迭代时不能使用集合方法(add, remove, set)  更改集合元素！

Collection<String>  eggs = new HashSet<String>();
egg.add("鸡蛋");
egg.add("鸭蛋");
Iterator<String>  it = eggs.iterator();//it是eggs的集合的视图（另一种外观）
    it =["鸡蛋" ,"鸭蛋"] //it是顺序结构，含有一个游标，在第一个元素之前
while(it.hasNext()){         //检查当前游标是否有下一个 
    String  egg = it.next();         //移动游标，返回下一个
}

hasNext()和 next()方法是模式化的，配合 while 循环使用
注意：每调用一次 next()，游标会向后移动一位
remove()方法一定要在 next()方法后执行，删除的是 next()返回的元素

 

集合的工具类  Collections **
同数组的工具类 Arrays 相同，集合的工具类为 Collections，其中提供了许多的方法，诸如排序、
二分查找、打乱、填充等操作。

排序：
Collections.sort(new ArrayList());
二分法查找：
int  index = Collctions.binarySearch(new ArrayList(),要查找的对象);
乱序：
Collctions.shuffle(new ArrayList());

Comparable 和 Comparator *
Comparable 
1、  表示可以比较的（用于类实现）
2、  实现这个接口表示：这个类的实例可以比较大小，可以进行自然排序
3、  conpareTo()  返回正数表示大,  返回负数表示小,  返回 0 表示相等
4、  Comparable 的实现必须不 equals()  的结果一致，就是相等的对象时候,  比较结果一定是 0！ 
Comparator 
1、  比较工具
2、  用于临时定义比较规则，丌是默认比较规则

1)String 重写的compareTo()方法：
   int a ="Tom".compateTo("Jerry");

2)按自定义比较规则排序：
class  ByLength  implements  Comparator<String>{
    public  int  compare(String o1 ,String o2){
 return  -(o1.length() - o2.length());
    }
}
List<String>  names = new ArrayList<String>();
names.add("Tom");
names.add("Toms");
ByLength  byLength  =new ByLength();
Collections.sort(names,byLength);

 

set集合

 

 

map集合

HashMap 还有一些常用方法，请参照 API 练习
?  clear()
?  containsKey(Object key)
?  containsValue(Object value)
?  get()
?  isEmpty()
?  keySet()          返回所有的 key（注意：返回值都放入 set 集合中）
?  put(key , value)      向 Map 中加入元素
?  remove(Object o)
?  size()

 

Map迭代：

对 key        进行迭代      map.keySet();

对 value      进行迭代      map.values();

对 key:value  进行迭代      map.entrySet();

Set<Character>  keys = map.keySet();

Collection<Integer>  values = map.values();
Set<Entry<Character,Integer>>  entrySet = map.entrySet();//返回键值对集合
ArrayList<Entry<Character,Integer>>  list = new ArrayList<Entry<Character,Integer>>(entrySet);//复制为List集合（便于排序）
Collections.sort(list,new ByValue());//按指定规则排序

class  ByValue  implements  Comparator<Entry>{
 public  int  compare(Entry  o1,Entry  o2){
  return  (Integer) o2.getValue() - (Integer) o1.getValue();
 }
} 
Map.Entry 类型  Entry 就是键值对[key：value]，通过 map.entrySet()方法获得
class ByValue{}最好写为静态内部类