黑马程序员--java基础--集合框架

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

目录：1、体系概述 2、迭代器3、list集合共性方法 4 、List集合具体对象的特点 5、Set集合6、Map集合

1、集合框架：体系概述

为了方便对多个对象的操作，就对对象进行存储，集合就是
 存储对象最常用的一种方式

集合只用于存储对象，集合的长度是可变的，集合可以存储不同类型的对象
 在看一个体系的时候，要看体系的最顶层，因为顶层当中定义的是体系中最基本，最共性的东西
 Collection有两个常见的子接口，一个是List(ArrayList,LinkedList,vector)一个是Set(HashSet,TreeSet)

2、集合框架：迭代器

iterator()：返回此collection的元素上进行迭代的迭代器，它的返回值类型是一个接口Iterator
 Iterator接口中定义了三个方法：1 hasNext() 如果仍有元素可以迭代，则返回true
         2 next() 返回迭代的下一个元素
         3 remove() 从迭代器执行的collection中移除迭代器返回的最后一个元素

//迭代器的基本使用class CollectionDemo{ public static void main(String[] args) {  method_get(); } public static void method_get() {  ArrayList al = new ArrayList();  al.add("java01");//add(Object obj)  al.add("java02");  al.add("java03");  al.add("java04");/*  Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素.  while(it.hasNext())//加hasNext()的方法的原因是,只要有可以迭代的元素就返回true  {   sop(it.next());  }  */  //老外不喜欢这样的书写方式,这儿写while循环也行  for(Iterator it = al.iterator();it.hasNext();)  {   sop(it.next());  } }}

3、list集合共性方法

Collection下有两个最常用的子类
 List(): List也是一个抽取出来的接口，这个集合体系它里面的特点在于元素是有序的，元素可以重复，因为该集合体系有索引，所以元素可以重复
  set(): 元素是无序,元素不可以重复，该集合当中没有索引

List()方法中的特有方法：凡是操作角标的都是list的特有方法
                 add(int index,E element): 在列表的指定位置插入指定元素 
addAll(int index,Collection<?extend E> c): 将指定collection中的所有元素都插入到列表中的指定位置
         get(int index): 返回列表中指定位置的元素.
      indexOf(Object o):  返回此列表中最后出现的指定元素的索引，如果列表不包含此元素,则返回-1
         listIterator(): 返回此列表元素的列表迭代器
      remove(int index): 移除列表中指定位置的元素
       remove(Object o): 从此列表中移除第一次出现的指定元素
        set(int index,E element): 用指定元素替换列表中指定位置的元素.(就list方法中有这个特有方法)
    subList(int fromIndex,int toIndex): 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图

增 add(index,element)
    addAll(index,Collection)

删  remove(index)

改  set(index,element)

查  get(index)
    subList(from,to)
 ListIterator();

4List集合具体对象的特点

list:方法中三个常见的子类对象
   1 ArrayList: 底层的数据结构使用的是数组结构,特点在于,查询速度很快.但是增删较慢
   2 LinkList: 底层使用的是链表数据结构.特点:增删的速度很快,查询的速度很慢
   3 Vector: vector底层是数组数据结构

   ArrayList和Vector的区别?
   1 Vector出现在jdk1.1,较早，而ArrayList出现在1.2
   2 Vector中线程同步的，而ArrayList中的线程是不同步的，在开发一般用ArrayList,因为ArrayList无论增删改查都很快
   3 ArrayList的默认长度是10，如果超过该长度,会new一个数组50%延长，而Vector是100%延长

LinkedList

LinkList特有方法
 addFirst(E e): 将指定元素插入此列表的开头
  addLast(E e): 将指定元素添加到此列表的结尾
 
  getFirst(): 返回此列表的第一个元素
  getLast(): 返回此列表的最后一个元素
   
  removeFirst(): 移除并返回此列表的第一个元素
  removeLast(): 移除并返回此列表的最后一个元素

inmport java.util.*;class LinkListDemo{ public static void main(String[] args) {  LinkedList link = new LinkedList();  link.addFirst("java01");  link.addFirst("java01");  link.addFirst("java01");  link.addFirst("java01");  sop(link); } public static void sop(Object obj) {  System.out.println(obj); }}

List集合练习

List集合判断元素是否相同，依据的是元素的equals方法！其他集合不是这样的！

 需求：将自定义对象作为元素存到ArrayList集合中，并去除重复元素
 
 比如：存人对象.同姓名同年龄视为同一个人，为重复元素

 思路:
 1 对人描述,将数据封装进入对象
 2 定义容器,将人存入
 3 取出

class Person{ private String name; private int age; Person(String name, int age) {  this.name= name;  this.age = age; } public boolean equals(Object obj)//这里的equals是Person类中的 {  if(!(obj instanceof Person))   return false;   //想要程序更严谨,也可以抛异常   Person p = (Person)obj;   System.out.println(this.name+"---"+p.name);    return this.name.equals(p.name) && this.age == p.age;//这里是字符串中的equals } public String getName() {  return name; } public void setName() {  this.name = naem; } public int getAge() {  return age; } public void setName() {  this.age = age; }}class ArrayListTest2{ public static void sop(Object obj) {  System.out.println(obj); } public static void main(String[] args) {  ArrayList al = new ArrayList();  al.add(new Person("lisi01",30));//al.add(Object obj);然后就相当于Object obj = new Person("lisi",30);  al.add(new Person("lisi02",32));  al.add(new Person("lisi03",33));  al.add(new Person("lisi04",35));  al.add(new Person("lisi02",32));  al.add(new Person("lisi03",33));  //存完了,然后取一下,用迭代器  Iterator it = al.iterator();  while(it.hasNext())  {   Object obj = it.next()//返回Object类型,因为迭代器它不知道里面放的是什么,所以要返回Obeject   //想用子类特有对象,向下转型   Person p = (Person)obj;   sop(it.next().getName());   /*    上述代码还可以简化为:    Person p = (Person)it.next();   */   Sop(p.getName()+"---"+p.getAge());  } } //定义一个临时容器 public static ArrayList singelElement(ArrayList al) {  ArrayList newAl = new ArrayList();  Iterator it = new Iterator();    while(it.hasNext())  {   Object obj = it.next();      if(!newAl.contains(obj))//判断元素是否相等用contains方法    newAl.add(obj);  } }}

5、Set集合

Set集合特点：无序,不可以重复
 Set集合下有两个子类：

  1.HashSet: 数据结构是哈希表，线程是非同步的
     依据哈希表数据结构，保证元素唯一性的原理是:
     判断元素的哈希值是否相同，如果相同还会继续判断元素的equals方法是否为真

  2.TreeSet集合特点：可以对set集合中的元素进行排序.
    
    重要:底层数据结构是二叉树数据结构,保证元素唯一性的依据是compareTo方法和return0 >

   
    TreeSet排序的第一种方式: 让元素自己身上具有可比性.
    让元素自身具备比较性,元素需要实现Comparable接口,覆盖compareTo方法
    这种方式也称为元素的自然顺序,或者叫做默认顺序.

 

TreeSet存储自定义对象
需求： 往TreeSet集合中存储自定义对象学生
    想按照学生的年龄进行排序
 TreeSet集合能够排序，但是传入的对象必须具备比较性，往TreeSet集合中存不入相同集合元素

import java.util.*;class TreeSetDemo{ public static void main(String[] args) {  //建立TreeSet集合  TreeSet ts = new TreeSet();  ts.add(new Student("lisi02",22));  ts.add(new Student("lisi07",20));  ts.add(new Student("lisi08",19));  ts.add(new Student("lisi10",30));    //ts调用迭代器方法  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; }//实现Comparable接口要复写其中的方法,int compareTo(Object obj)  public int CompareTo(Object obj)//CompartTo方法中,传入的是任意对象. {  //先判断传入的对象obj是不是Student对象  if(!(obj instanceof Student))   throw new RuntimeException('您所传入的对象不属于Student对象');  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; }}

二叉树

排序无非就是互相比较，元素越多，你所比较的次数就越多，运行速度越慢，为了优化速度，TreeSet底层
 的二叉树数据结构做这些事情

 二叉树原理：在取数据的时候，从小到大取数据
 二叉树就是以return 0 来判断元素是否相同

TreeSet集合的第二种排序方式:让集合具备可比性

 

排序有两种要素，集合和元素，当元素不具备可比性的时候，只能考虑集合具不具备可比性
 当元素自身不具备比较性，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性
 在集合一初始化时,就有了比较方式.

当TreeSet集合中的两种排序方式都存在时，以比较器为主.
定义一个类实现Comparator接口，覆盖compare方法

当元素自身不具备比较性，或者具备的比较性不是需要的，这时需要让容器具有比较性
这时就需要定义比较器，将比较器作为参数传递给TreeSet集合的构造函数

import java.util.*;class TreeSetDmeo2{ public static void main(String[] args) {  //建立TreeSet集合  TreeSet ts = new TreeSet(new MyCompare());//new MyCompare 比较器对象  ts.add(new Student("lisi02",22));  ts.add(new Student("lisi07",20));  ts.add(new Student("lisi08",19));  ts.add(new Student("lisi10",30));    //ts调用迭代器方法  Iterator it = ts.Iterator();  while(it.hasNext())  {   //如果想要打印具体学生对象的话   Student stu = (Student)it.next()   System.out.println(stu.getName()+"---"stu.getAge());  } }}//写一个比较器class MyCompare implements Comparator{ //这里没必要再覆盖其equals方法,equals方法是用来健壮性的判断两个元素是否相等 public int compare(Object o1,Object o2) {  Student s1 = (Student)o1;  Student s2 = (Student)o2;  //判断姓名是否形同,并且记录姓名排完的正数负数0  int num = return s1.getName().compareTo(s2.getName());//compareTo比较后返回的是-1,0,1  if(num == 0)  {   //把数字封装成对象   return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));   /*   if(s1.getAge()>s2.getAge())    return 1;   if(s1.getAge()==s2.getAge())    return 0;   return -1;   */  }  return num; }}

6、Map集合
 Map的三个子类：

Hashtable:底层是哈希表数据结构，不可以存入null键,null值.该集合是同步的,JDK1.0出现的，效率低
 HashMap:底层是哈希表数据结构。并允许使用null键和null值，该集合是不同步的,JDK1.2出现的，效率高
 TreeMap:底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序

Set底层就是使用了Map集合

Map-keySet

map集合的两种取出方式此板块着重讲keySet
1Set<k> keySet:将map中所有的键存入到Set集合，因为set具备迭代器
 所有可以迭代方式取出所有的键，再根据get方法获取每一个键对应的值
 
 Map集合的取出原理：将map集合转换成set集合，通过迭代器取出

import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;class MapTest { public static void main(String[] args) {  Map<String,String> map = new HashMap<String,String>();    //添加元素  map.put("01","zhangsan01");  map.put("02","zhangsan02");  map.put("04","zhangsan04");  map.put("03","zhangsan03");    //利用KeySet方法，获取Set值  Set<String> keySet = map.keySet();    //利用Set的迭代器获取键值,注意，此处的泛型要与Set的泛型一致  Iterator<String> it = keySet.iterator();    while(it.hasNext())  {   String key = it.next();   //通过键值获取Value值   String Value = map.get(key);   sop("key:"+key+",Value:"+Value);  } } public static void sop(Object obj) {  System.out.println(obj); }}

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