黑马程序员技术交流社区

标题: 集合框架 [打印本页]

作者: hihi    时间: 2015-6-26 17:41
标题: 集合框架
  1. 集合框架
  2.         Java平台提供了一个全新的集合框架。“集合框架”主要由一组用来操作对象的接口组成。不同接口描述一组不同数据类型。它们都封装在java.util包中


  3. 核心接口
  4.         Java集合框架的核心接口有两种:Collection(聚集)和Map(映射)

  5.         Collection 接口是一组允许重复的对象。
  6.         Set 中的数据对象没有顺序且不可以重复。接口
  7.         List中的数据对象有顺序且可以重复。接口

  8.         Map接口是一组成对的键-值对象,即所持有的是key-value pairs。Map中不能有重复的key。拥有自己的内部排列机制。不能有重复的键
  9. Collection
  10.         类 java.util.Collections 提供了一些静态方法实现了基于List容器的一些常用算法
  11.         void sort(List l)  对List容器内的元素排序
  12.         void shuffle(List l) 对List容器内的对象进行随机排列
  13.         void reverse(List l) 对List容器内的对象进行逆续排列
  14.         void fill(List l, Object o)  
  15.         用一个特定的对象重写整个List容器
  16.         void copy(List dest,List src)
  17.         将src List容器内容拷贝到dest List容器
  18.         int binarySearch(List l, Object o)
  19.         对于顺序的List容器,采用折半查找的方法查找特定对象


  20. 例题:
  21. List l1 = new LinkedList();
  22. List l2 = new LinkedList();
  23. for(int i=0; i<=9; i++) { l1.add("a"+i); }
  24. System.out.println(l1);
  25. Collections.shuffle(l1); //随机排列
  26. System.out.println(l1);  
  27. Collections.reverse(l1); //逆续
  28. System.out.println(l1);
  29. Collections.sort(l1); //排序
  30. System.out.println(l1);
  31. System.out.println(Collections.binarySearch(l1,“a5”)); //折半查找
  32. List

  33.         List接口是Collection的子接口,实现List接口的容器类中的元素是有顺序的,而且可以重复
  34.         List 容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
  35.         List 接口中所定义的方法:
  36.         Object get(int index);
  37.         Object set(int index, Object element);            
  38.         void add(int index, Object element);            
  39.         Object remove(int index);                       
  40.         int indexOf(Object o);
  41.         int lastIndexOf(Object o);
  42. ————————————————————————————————————————————————————————————————————————————————————————————————————————————
  43. List接口的实体类——LinkList类

  44.         第一步,确定存储方式
  45. 1、LinkedList类是List接口的一个具体实现类
  46. 2、LinkedList 类用于创建链表数据结构
  47. 3、插入或者删除元素时,它提供更好的性能
  48.         创建一个类Stack,代表堆栈(其特点为:后进先出),添加方法add(Object obj)、以及get(),添加main方法进行验证,要求:
  49.         使用LinkedList实现堆栈
  50.         在向LinkedList中添加时,使用addLast方法
  51.         在从LinkedList中取出时,使用removeLast方法

  52. import java.util.*;
  53. public class MyStack {
  54.         /**
  55.          * List的实现类LinkedList
  56.          * LinkedList存储时按照后进先出的原则
  57.          */
  58.         private LinkedList<Object> stack=new LinkedList<Object>();
  59.         /**
  60.          * 把对象存入LinkedList的第一个位置
  61.          */
  62.         public void push(Object o)
  63.         {
  64.                 stack.addFirst(o);
  65.         }
  66.         /**
  67.          * @param args
  68.          * 把第一个位置的对象进行删除
  69.          */
  70.         public Object pop()
  71.         {
  72.                 return stack.removeFirst();
  73.         }
  74.         /**
  75.          * 取得LinkedList的第一个元素
  76.          */
  77.         public Object peek()
  78.         {
  79.                 return stack.getFirst();
  80.         }
  81.         public static void main(String[] args) {
  82.                 MyStack m=new MyStack();
  83.                 m.push("wangwu");
  84.                 m.push("zhangsan");
  85.                 m.push("lisi");
  86.                 System.out.println("现在箩筐顶部的元素是:"+m.peek());
  87.                 m.pop();
  88.                 System.out.println("现在箩筐顶部的元素是:"+m.peek());
  89.         }
  90. }
  91. ArrayList类
  92. import java.util.ArrayList;
  93. public class TestArrayList {
  94.         /**
  95.          * List接口的第二个实现类,按照先进先出
  96.          */
  97.         public static void main(String[] args) {
  98.                 ArrayList<String> list=new ArrayList<String>();
  99.                 list.add("a");
  100.                 list.add("b");
  101.                 list.add("c");
  102.                 for (int i=0;i<list.size();i++)
  103.                 {
  104.                         String temp=list.get(i);
  105.                         System.out.println(temp);
  106.                 }
  107.         }
  108. }
  109. ——————————————————————————————————————————————————————————————————————————————————————————————————
  110. import java.util.ArrayList;
  111. class Student
  112. {
  113.         public String name;
  114.         public int num;
  115.         public String address;
  116.         public Student(String name,int num,String address)
  117.         {
  118.                 this.name=name;
  119.                 this.num=num;
  120.                 this.address=address;
  121.         }
  122.         public String getName() {
  123.                 return name;
  124.         }
  125.         public void setName(String name) {
  126.                 this.name = name;
  127.         }
  128.         public int getNum() {
  129.                 return num;
  130.         }
  131.         public void setNum(int num) {
  132.                 this.num = num;
  133.         }
  134.         public String getAddress() {
  135.                 return address;
  136.         }
  137.         public void setAddress(String address) {
  138.                 this.address = address;
  139.         }       
  140. }
  141. public class Arrayzuoye {
  142.         /**
  143.          * 利用ArrayList来存储一个小学生类,学生类有学号,姓名,住址三个属相,实例化出一个学生“张三”。并且进行遍历取出
  144.          * 集合中不是真正存入某个对象, 而是保存的是对象的引用
  145.          */
  146.         public static void main(String[] args) {
  147.                 ArrayList<Student> list=new ArrayList<Student>();
  148.                 Student s=new Student("张三",1000000,"中国");
  149.                 //把张三这个对象存入ArryList中
  150.                 list.add(s);
  151.         //        s.setName("李四");
  152.                 System.out.println(list.get(0).name);               
  153.         }
  154. }
  155.         ArrayList类封装了一个动态再分配的Object[]数组。

  156.         集合框架中保存的都是对象的引用,        不是对象的备份。这一点尤其重要

  157. ————————————————————————————————————————————————————————————————————————————————————————————————————————————————

  158. Iterator接口

  159.         所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象。
  160.         Iterator对象称作迭代器,用以方便的实现对容器内元素的遍历操作。
  161.         Iterator接口定义了如下方法:
  162.         boolean hasNext();  //判断游标右边是否有元素
  163.         Object next();  //返回游标右边的元素并将游标移动到下一个位置
  164.         void remove();      //删除游标左面的元素,在执行完next之后该

  165. Set接口
  166. Set 接口继承 Collection 接口,它不允许集合中存在重复项, 而且它不象List按照加入列表的顺序存储元素,它有自己的排列法则。
  167.         Set 接口是Collection的子接口,Set接口没有提供额外的方法,但实现 Set 接口的容器类中的元素是没有有顺序的,而且不可以重复

  168.         Set 容器可以与数学中“集合”的概念相对应
  169.         J2SDK API中 所提供的 Set 容器类有 HashSet,TreeSet 等


  170. HashSet类
  171.         用HashSet过滤自定义类。一般认为如果学号一致,就应该是同一个人。本例的过滤规则就是同学号的学生将保留一个。
  172.                
  173.                 //问题1:如何打印出来就是姓名+学号这种形式呢?
  174.                 //问题2:set中存储的对象如果hashCode一致,就认为是一个对象
  175.                 //只要对象学号的hasCode一致,set进行自动过滤
  176.                 //iter.next()进行对象实例化时,会自动调用类中隐藏的方法
  177.                 for(Iterator<Student> iter=set.iterator();iter.hasNext();)
  178.                 {
  179.                         System.out.println(iter.next());
  180.                 }
  181.         }
  182. }
  183. LinkedHashSet的用法
  184. LinkedHashSet是HashSet的子类,用法和HashSet一致。


  185. Map接口
  186.         Map接口不是Collection接口的继承。Map接口用于维护键/值对(key/value pairs)。
  187.         该接口描述了从不重复的键到值的映射。

  188.         实现Map接口的类用来存储键-值 对。

  189.         Map 接口的实现类有HashMap(查找速度最快)和TreeMap等,HashMap通过hashcode对其内容进行快速查找,而TreeMap中所有的元素都保持着某种固定的顺序 。

  190.         Map类中存储的键-值对通过键来标识,所以键值不能重复
  191. Map 接口方法
  192. Object put(Object key, Object value);
  193. Object get(Object key);
  194. Object remove(Object key);
  195. boolean containsKey(Object key);
  196. boolean containsValue(Object value);
  197.         第一步,确定存储方式
  198. 1、Map接口用于维护“键-值对”的关联性,可以通过键查找值
  199. 2、HashMap是Map接口的一个具体实现类
  200. ————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

  201. import java.util.HashMap;
  202. import java.util.Iterator;
  203. public class MapTest {
  204.         /**
  205.          * @param args
  206.          */
  207.         public static void main(String[] args) {
  208.                 HashMap<String,String> map=new HashMap<String,String>();
  209.                 map.put("001","aaaaaaaaaa");
  210.                 map.put("002","bbbbbbbbbbbb");
  211.                                

  212. 总结:
  213.         Java的集合框架分别派生自Collection和Map接口。
  214.         Collection有两个常用子接口List和Set,分别表示有序可重复,无序不可重复的集合。

复制代码



作者: keto    时间: 2015-6-26 19:45
额。学习学习。。。
作者: 含笑    时间: 2015-6-26 21:53
  HashMap<String,String> map=new HashMap<String,String>();什么意思不懂
作者: 1千克=1024克    时间: 2015-6-26 22:03
含笑 发表于 2015-6-26 21:53
HashMap map=new HashMap();什么意思不懂

HashMap存放的是映射   俗话说就是键值对  一个键对应一个值  这里定义了一个HashMap  通过泛型确定了 HashMap的键和值的类型都是String
作者: lwen    时间: 2015-6-26 22:12
这个整理的还不错,好好学习到这里了,给赞一个
作者: 贾森    时间: 2015-6-26 22:31
学习了




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2