集合学习整理

遍历的常用方法：for循环、迭代器、增强for循环、或者采用toArray的方法将其转成字符数组进行遍历  
一、下面这些遍历是基于一个键或者值得。
1。迭代器的用法：作为一个遍历的方法
通常将给定的集合，采用迭代器创建迭代器对象的方法，采用while循环进行判断是否还有下一个元素iter.hasNext(),如果有的话，就可以进行赋值，即iter.next()。
其具体形式为：
Iterator  iter = c.iterator();  //其中c代表的集合
  while(iter.hasNext()){
   String s= iter.next()
  System.out.println(s);
  }
这种形式就可以进行判断了。


迭代器判重（在原有未重复的基础上同时添加元素）：由于Iterator不具有添加功能，而ListIterator具有添加功能，所以需要用迭代器Iterator的子类ListIterator进行添加
ListIterator lit = c.listIterator();
while(lit.hasNext()) {
String s = (String)lit.next();
if(s.equals("java")) {
lit.add("android");
}
}


2.采用toArray()的方法进行遍历
//注：c是集合
Object[] objs = c.toArray();
//遍历数组
for (int i = 0; i < objs.length; i++) {
System.out.println(objs[i]);
}
3.增强for循环
for(数据类型  变量名 ：遍历的集合或者数组）{
System.out.println(数据类型);


如：
for (String string : c) {
c.add("android");
System.out.println(string);

4.for循环：
for(int i =0;i<c.size();i++){
  String s = c.get(i);
  System.out.println(s);
}


二、list子类体系：
1.list
  void add(int index, E element) :将元素添加到index索引位置上
E get(int index) :根据index索引获取元素
E remove(int index) :根据index索引删除元素
E set(int index, E element):将index索引位置的的元素设置为element
特点：
有序的（存储和读取的顺序是一致的）
  有整数索引
  允许重复的
与HashMap不同，HashMap是不允许重复，而且是乱序的
与TreeSet不同，TreeSet是不允许重复，而且是有序的

public class ListDemo {
public static void main(String[] args) {
//创建的列表对象
List list = new ArrayList();

//void add(int index, E element)  : 在指定索引位置添加指定元素
list.add(0, "hello");
list.add(0, "world");
list.add(1, "java");
      System.out.println(list.set(0, "android"));
System.out.println(list);
}
}


2.LinkedList特有功能
    LinkedList底层使用的是链表结构,因此增删快,查询相对ArrayList较慢
    void addFirst(E e) :向链表的头部添加元素
   void addLast(E e):向链表的尾部添加元素
   E getFirst():获取链头的元素,不删除元素
   E getLast():获取链尾的元素,不删除元素
   E removeFirst():返回链头的元素并删除链头的元素
   E removeLast():返回链尾的元素并删除链尾的元素


/*
 * 需求：定义一个方法，返回指定列表中指定元素的索引位置
 * 
 * 判断元素是否存在
 * 
 */
public class ListTest {
public static void main(String[] args) {
List list = new ArrayList();
list.add("hello");
list.add("world");
list.add("java");

//int index = index(list,"php");
//System.out.println(index);

//boolean flag = contains(list, "php");
//System.out.println(flag);

boolean flag = list.contains("php");
System.out.println(flag);
}

public static int index(List list,Object other) {
for(int x = 0;x < list.size();x++) {
//获取列表中的元素
Object obj = list.get(x);
//使用列表中的元素和指定的元素进行比较
if(obj.equals(other)) {
return x;
}
}
//查找不到指定的元素
return -1;
}

public static boolean contains(List list,Object other) {
//获取指定元素在指定列表中的索引位置
int index = index(list,other);
//如果索引位置大于等于0，则认为元素存在，否则不存在
if(index >= 0) {
return true;
}
else {
return false;
}
}
}


三、HashSet
 set集合的特点
    存入集合的顺序和取出集合的顺序不一样 
没有索引
存入集合的元素没有重复


HashSet使用&唯一性原理
HashSet<Student> hs = new HashSet<Student>();//使用的形式与之类似
对于给出的重复的，他将会去重
四、Collections:
  Collections是一个工具类，方法都是用于操作Collection
  Collection是集合体系的最顶层，包含了集合体系的共性
  public class CollectionsDemo {
public static void main(String[] args) {
//static void swap(List list, int i, int j) :将指定列表中的两个索引进行位置互换
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(4);
Collections.swap(list, 0, 1);

System.out.println(list);

}


private static void method6() {
//static void  sort(List<T> list) :按照列表中元素的自然顺序进行排序
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(4);
list.add(3);
list.add(2);

Collections.sort(list);
System.out.println(list);
}


private static void method5() {
//static void shuffle(List list):傻否，随机置换  
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Collections.shuffle(list);
System.out.println(list);
}


private static void method4() {
//static void reverse(List list)  :反转
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);

Collections.reverse(list);
System.out.println(list);
}


private static void method3() {
//static void fill(List list, Object obj) :使用指定的对象填充指定列表的所有元素
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
System.out.println(list);

Collections.fill(list, "android");

System.out.println(list);
}


private static void method2() {
//static void copy(List dest, List src) :是把源列表中的数据覆盖到目标列表
//注意：目标列表的长度至少等于源列表的长度
//创建源列表
List<String> src = new ArrayList<String>();
src.add("hello");
src.add("world");
src.add("java");

//创建目标列表
List<String> dest = new ArrayList<String>();
dest.add("java");
dest.add("java");
dest.add("java");
dest.add("java");
Collections.copy(dest, src);
System.out.println(dest);
}


private static void method() {
//static int  binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置 
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);

int index = Collections.binarySearch(list, 4);
System.out.println(index);
}
}




五、HashMap集合
     V put(K key, V value) :以键=值的方式存入Map集合
B:获取功能：
     V get(Object key):根据键获取值
int size():返回Map中键值对的个数
C:判断功能：
boolean containsKey(Object key):判断Map集合中是否包含键为key的键值对
boolean containsValue(Object value):判断Map集合中是否包含值为value键值对
boolean isEmpty():判断Map集合中是否没有任何键值对 
D:删除功能：
 void clear():清空Map集合中所有的键值对
 V remove(Object key):根据键值删除Map中键值对
E:遍历功能：
 Set<Map.Entry<K,V>> entrySet():将每个键值对封装到一个个Entry对象中,再把所有Entry的对象封装到Set集合中返回
 Set<K> keySet() :将Map中所有的键装到Set集合中返回
 Collection<V> values():返回集合中所有的value的值的集合


 HashMap的遍历方法：
//HashMap的遍历方法：
    采用迭代器有两种方法；keySet和entrySet
采用增强for循环

//方法1：增强for循环
 
for(Map.Entry<Student, String> m:hm.entrySet()){
System.out.println(m);
}
 
//方法2：采用迭代器Interator entrySet
Iterator iter = hm.entrySet().iterator();
while(iter.hasNext()){
Map.Entry  entry = (Map.Entry)iter.next();
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key+"="+value);
}
 
//方法3： 采用迭代器 Intertor keySet
Iterator iter1 = hm.keySet().iterator();
while(iter1.hasNext()){
Object key = iter1.next();
Object  value = hm.get(key);
System.out.println(key+"="+value);
}