黑马程序员_JAVA集合类函数总结

------- android培训、java培训、期待与您交流！ ----------

collection

      ---List:元素有序，可重复，有索引

          ---ArrayList:底层的数据结构是数组结构               查询快，增删稍慢

          ---LinkedList:底层是链表结构                              增删快，查询稍慢

          ---Vector:底层数组结构，线程同步，被淘汰         慢

     ---Set:元素无序，不可重复

          ---HashSet底层结构是哈希表

          ---TreeSet

ArrayList   a1 = new ArrayList()

a1.add();添加元素 a1.size();集合大小 a1.remove();移除元素 a1.clear();清空集合

a1.isEmpty();是否为空 a1.contains();是否存在某元素 a1.retainAll(a2);取交集 a1.removeAll(a2);删除多个元素

list特有方法（带角标）：

a1.add(1,"java98");特定角标处添加元素 a1.remove(2);移除特定角标元素 a1.set(2,"java89");更改特定角标元素

a1.get(1);获取角标元素 a1.subList();

用角标遍历集合可以获取所有元素， 用迭代器也可以获取所有元素。

迭代器

Iterator it = a1.iterator();

for( it.hasNext())-------并发修改安全隐患

{

      sop(it.next());

}

列表迭代器

List集合特有迭代器，是Iterator的子接口

ListIterator li = a1.ListIterator();     可以进行增删改查

while(li.hasNext())--------------li.hasPrevious()

{

      Object obj = li.next();

      if(obj.equals("java23"))

               li.add("java43");

}

Vector v = new Vector();

addElement();

elements();

Enumeration en = v.elements();

while(en.hasMoreElements())

{

      System.out.println(en.nextElement());

}

枚举是vector的特有取出方式， Enumeration和Iterator功能是重复的。

LinkList特有方法：

addFirst(); getFirst(); removeFirst();

addLast(); getLast(); 获取元素，不删除 removeLast(); 获取元素，并删除

集合中没有元素，会抛出异常

JDK1.6中替代方法

offerFirst(); peekFirst(); pollFirst();

offerLast(); peekLast(); 获取元素，不删除 pollLast(); 获取元素，并删除

LinkedList link = new LinkedList();

link.addLast("java01");

link.addLast("java02");

link.addLast("java03");

link.addLast("java04");

link.size()

不用迭代器

while(!link.isEmpty())

{

      sop(link.removeFirst());

}

使用LinkList模拟队列或堆栈数据结构

堆栈：先进后出

队列：先进先出

class Duilie
{
     private LinkedList link;
     Duilie()
     {
          link = new LinkedList();
     }
     
     public void myAdd(Object obj)
     {
            link.addFirst(obj);
     }
     public Object myGet()
     {
          return link.removeLast();
     }
     public boolean isNull()
     {
          return link.isEmpty();
     }
}

class LinkedListTest
{
     public static void main(String[] args)
     {
          Duilie di = new Duilie();
          di.myAdd("java01");
          di.myAdd("java02");
          di.myAdd("java03");
          di.myAdd("java04");

          System.out.println(d1.myGet());
     }
}

HashSet 保证元素唯一性以及判断元素是否存在和删除等操作依赖的都是元素的hashCode和equals方法。

HashSet hs =  new HashSet();

hs.add("java01");//返回值为Boolean型

hs.add("java01");//添加失败，为假，成功为真

hs.add("java02");

hs.add("java03");

hs.add("java04");

Iterator it = hs.iterator();

while(it.hasNext())

{

      sop(it.next());

}

实例

<span style="font-size:14px;">class  HashSetDemo
{
     public static void sop(Object obj)
     {
          System.out.println(obj);
     }
     public static void main(String[] args)
     {
          HashSet hs = new HashSet();

          hs.add(new Person("a1",11));
          hs.add(new Person("a1",11));
          hs.add(new Person("a1",11));
          hs.add(new Person("a1",11));
          hs.add(new Person("a1",11));

          sop(hs.contains(new Person("a2",12)));
          hs.remove(new Person("a3",13));

          Iterator it = hs.iterator();

          while(it.hasNext())
          {
               Person p = (Person)it.next();
               sop(p.getName()+"::"+p.getAge());
          }
     }
}
class Person
{
     private String name;
     private int age;
     Person(String name,int age)
     {
          this.name = name;
          this.age = age;
     }

     public int hashCode()
     {
          System.out.println(this.name+"....hashcode");
          return name.hashCode();
     }

     public boolean equals(Object obj)
     {
          if(!(obj instanceof Person))
               return false;

          Person p = (Person)obj;
          System.out.println(this.name+"...equals..."+p.name);

          return this.name.equals(p.name) && this.age == p.age;
     }

     public String getName()
     {
          return name;
     }
     public int getName()
     {
          return age;
     }
}
</span>

TreeSet可以对Set集合的元素进行自然排序

TreeSet ts = new TreeSet();

ts.add("cba");

ts.add("aaa");

ts.add("bcd");

ts.add("awf");

ts.add("wds");

Iterator it = ts.iterator();

while(it.hasNext())

{

      System.out.println(it.next());

}

TreeSet集合第一种排序方式：对象不具备比较性，需要实现comparable接口

<span style="font-size:14px;"><span style="font-size:14px;">class  TreeSetDemo
{
     public static void main(String[] args)
     {
          TreeSet ts = new TreeSet();

          ts.add(new Student("lisi02",22));
          ts.add(new Student("lisi04",26));
          ts.add(new Student("lisi05",15));
          ts.add(new Student("lisi06",43));
          ts.add(new Student("lisi07",12));

          Iterator it = ts.iterator();
          while(it.hasNext())
          {
               Student stu = (Student)it.next();
               System.out.println(stu.getName()+"..."+stu.getAge());
          }

     }
}
class Student implements Comparable
{
     private String name;
     private int age;

     Student(String name,int age)
     {
          this.name = name;
          this.age = age;
     }

     public int comparableTo(Object obj)
     {
          if(!(obj instanceof Student))
               throw new RuntimeException("不是学生对象")；
         
          Student s = (Student)obj;

          if(this.age>s.age)
               return 1;
          if(this.age==s.age)
          {
               return this.name.compareTo(s.name);
          }
          return -1;
     }
     public String getName()
     {
          return name;
     }
     public int getAge()
     {
          return age;
     }
}</span>

二叉树结构， compareTO返回1，正存正取， 返回-1正存反取， 返回0判断是否包含。

TreeSet集合第二种排序方式：元素不具备比较性，让集合具备比较性：

TreeSet ts = new TreeSet(new MyCompare);

class MyCompare implements Comparator
{
     public int compare(Object o1,Object o2)
     {
          Student s1 = (Student)o1;
          Student s2 = (Student)o2;

          return s1.getName().compareTo(s2.getName());
     }
}

注意：compareTo方法和comparator返回的都是正数负数或零。

MAP集合

Map<K,V>

该集合存储键值对，而且要保证键的唯一性。

1.添加

      put(K key,V value)   putAll(Map<? extends K,? extends V> m)

2.删除

      clear();

3.判断

      containsValue(Object value) containsKey(Object key) isEmpty();

4.获取

    get(Object key); size() values()

      entrySet() keySet()

Map :

---Hashtable:底层是哈希表，不可以存入null键null值，线程同步

---HashMap：底层是哈希表数据结构，允许使用null键null值，不同步

---TreeMap：底层是二叉树，不同步可以用于给Map集合中的键进行排序

Set底层使用的是Map集合

Map<String,String> map = new HashMap<String,String>()

map.put("01","zhangsan1");

map.put("02","zhangsan2");

map.put("03","zhangsan3");

map.containsKey("022");//返回FALSE

map.remove("02");//删除并返回zhangsan2

map.get("01");//不存在返回null，存在返回值

map.put(null,"haha");

map.put("04",null);//null键null值

map.get(null);

//获取map集合的所有值

Collection<String> coll = map.values();

添加元素，如果添加相同的键，那么后添加的值会覆盖原有的值，并且put方法会返回被覆盖的值

map.put("04","zhangsan");//返回null

map.put("04","lisu");//返回zhangsan

map集合的两种取出方式：

1.keySet:将map中所有的键存入Set集合，因为Set具备迭代器，可以迭代取出所有的键，然后用get方法，获取每一个键对应的值

Set<String> keySet = map.keySet();
Iterator<String> it = keySet.iterator();

while(it.hasNext())
{
     String key = it.next();
     String value = map.get(key);
     System.out.println("key:"+key+",value:"+value);
}

2.entrySet

Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了Set集合中， 而这个关系的数据类型是map.entry

//将map集合的映射取出，存入到Set集合中
Set<Map.Entry<String,String>> it = map.entrySet();

Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while(it.hasNext())
{
     Map.Entry<String,String> me = it.next();
     String key = me.getKey();
     String value = me.getValue();
}

Map.Entry Entry是一个接口，它是Map集合中的一个内部接口

interface Map
{
     public static interface Entry
     {
          public abstract Object getKey();
          public abstract Object getValue();
     }
}