黑马程序员---java---集合

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

集合框架

一，概念
Java平台提供了一个全新的集合框架。“集合框架”主要由一组用来操作对象的接口 组成。不同接口描述一组不同数据类型。它们都封装在java.util包中。
      图示：



核心接口：Java集合框架的核心接口有两种：Collection（聚集）和Map(映射)

Collection 接口是一组允许重复的对象。
包括：
Set 中的数据对象没有顺序且不可以重复。接口
List中的数据对象有顺序且可以重复。接口

Map接口是一组成对的键－值对象，即所持有的是key-value pairs。Map中不能有重复的key。拥有自己的内部排列机制。不能有重复的键。

Collection：
类 java.util.Collections 提供了一些静态方法实现了基于List容器的一些常用算法。

void sort(List l)  对List容器内的元素排序  

void shuffle(List l) 对List容器内的对象进行随机排列

void reverse(List l) 对List容器内的对象进行逆续排列

用一个特定的对象重写整个List容器 

void copy(List dest,List src)  

将src List容器内容拷贝到dest List容器  

int binarySearch(List l, Object o)  

对于顺序的List容器，采用折半查找的方法查找特定对象



例题：

List l1 = new LinkedList(); List l2 = new LinkedList();

for(int i=0; i<=9; i++)

{ l1.add("a"+i); }

System.out.println(l1);

Collections.shuffle(l1); //随机排列

System.out.println(l1);

Collections.reverse(l1); //逆续

System.out.println(l1);

Collections.sort(l1); //排序

System.out.println(l1);

System.out.println(Collections.binarySearch(l1,“a5”)); //折半查找

LIST





List接口是Collection的子接口，实现List接口的容器类中的元素是有顺序的，而且可以重复

List 容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号 存取容器中的元素。   

List 接口中所定义的方法：

Object get(int index);

Object set(int index, Object element);  

void add(int index, Object element);  

Object remove(int index);                        

int indexOf(Object o);

int lastIndexOf(Object o);

List接口的实体类——LinkList类




第一步，确定存储方式
1.LinkedList类是List接口的一个具体实现类 .
2、LinkedList 类用于创建链表数据结构 

3、插入或者删除元素时，它提供更好的性能  

创建一个类Stack，代表堆栈（其特点为：后进先出），添加方法add(Object obj)、 以及get()，添加main方法进行验证，要求：

使用LinkedList实现堆栈 ，在向LinkedList中添加时，

使用addLast方法 ，在从LinkedList中取出时，

使用removeLast方法  

import java.util.*;

public class MyStack {

/**   * List的实现类LinkedList
* LinkedList存储时按照后进先出的原则
*/
private LinkedList<Object> stack=new LinkedList<Object>();
/**
* 把对象存入LinkedList的第一个位置
*/

public void push(Object o)

{
stack.addFirst(o);
}
/**
* @param args
* 把第一个位置的对象进行删除
*/

public Object pop()
{
return stack.removeFirst();
}
/**
* 取得LinkedList的第一个元素
*/
public Object peek()

{
return stack.getFirst();
}
public static void main(String[] args) {

MyStack m=new MyStack();
m.push("wangwu");
m.push("zhangsan");
m.push("lisi");

System.out.println("现在箩筐顶部的元素是："+m.peek());

m.pop();

System.out.println("现在箩筐顶部的元素是："+m.peek());
}
}

ArrayList类

ArrayList
类

import java.util.ArrayList;
public class TestArrayList {
/**
* List接口的第二个实现类，按照先进先出
*/

public static void main(String[] args) {

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

list.add("a");

list.add("b");

list.add("c");

for (int i=0;i<list.size();i++)   {

String temp=list.get(i);

System.out.println(temp);

}  }

}

import java.util.ArrayList;

class Student {

public String name;

public int num;

public String address;

public Student(String name,int num,String address)  {

this.name=name;

this.num=num;

this.address=address;
}

public String getName() {
return name;
}

public void setName(String name) {

this.name = name;
}

public int getNum() {

return num;  }

public void setNum(int num) {

this.num = num;  }

public String getAddress() {

return address;  }

public void setAddress(String address) {

this.address = address;

}  }

public class Arrayzuoye {

/**

* 利用ArrayList来存储一个小学生类，学生类有学号，姓名，住址三个属相，实例化出一个学生“张三”。并且进行遍历取出

* 集合中不是真正存入某个对象， 而是保存的是对象的引用

*/

public static void main(String[] args) {

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

Student s=new Student("张三",1000000,"中国");

//把张三这个对象存入ArryList中

list.add(s);

// s.setName("李四");

System.out.println(list.get(0).name);

}

}

ArrayList类封装了一个动态再分配的Object[]数组。

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

import java.util.Date;

public class News {

private int id;

private String title;

private String
c280
creater;

private Date date;

public News(int id,String title,String creater,Date date)  {

this.id=id;
this.title=title;
this.creater=creater;
this.date=date;
}

public int getId() {
return id;
}

public void setId(int id) {

this.id = id;

}

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}
public String getCreater() {
return creater;

}

public void setCreater(String creater) {

this.creater = creater;

}

public Date getDate() {

return date;

}

public void setDate(Date date) {

this.date = date;

}

}

List接口的实体类ArrayList做删除  

<strong>
</strong>import java.util.ArrayList;

public class DelteArrays {

public static void main(String[] args) {
ArrayList<String> list=new ArrayList<String>();

list.add("1");
list.add("2");
list.add("3");
list.add("4");

String value="";

System.out.println(list.size());

for(int i=0;i<list.size();i++)   {

System.out.println(list.get(i));   }

for(int i=0;i<list.size();i++)   {

value=list.get(i);

if("3".equals(value))    {

list.remove(i);    }   }

System.out.println(list.size());

for(int i=0;i<list.size();i++)     {

System.out.println("使用传统遍历方式后"+"现在的值"+list.get(i)); <strong>
</strong>}

Iterator接口





所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了 Iterator接口的对象。

Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。

Iterator接口定义了如下方法：

boolean hasNext();  //判断游标右边是否有元素

Object next();  //返回游标右边的元素并将游标移动到下一个位置

void remove();      //删除游标左面的元素，在执行完next之后该                             
   
//操作只能执行一次

import java.util.ArrayList;
import java.util.Iterator;
public class DeleteByIterator {

public static void main(String[] args) {

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

list.add("3");
list.add("3");
list.add("3");
list.add("4");

String value="";
Iterator<String> it=list.iterator();        //对容器list的内容进行遍历

while(it.hasNext())              //游标在第一个元素的左边,判断下一个元素是否存在

{    value=it.next();
if("3".equals(value))
{
it.remove();
}
}

for(int i=0;i<list.size();i++)   {

System.out.println("现在的值"+list.get(i));

}
}
}

Set接口  

Set 接口继承 Collection 接口，它不允许集合中存在重复项, 而且它不象List按照加入列表的顺序存储元素，它有自己的排列法则。    

Set 接口是Collection的子接口，Set接口没有提供额外的方法，但实现 Set 接 口的容器类中的元素是没有有顺序的，而且不可以重复

 

Set 容器可以与数学中“集合”的概念相对应   

J2SDK API中 所提供的 Set 容器类有 HashSet，TreeSet 等

import java.util.HashSet;
import java.util.Iterator;
public class TestSet1 {
public static void main(String[] args) {

HashSet<String> set=new HashSet<String>();
set.add("1");
set.add("2");
set.add("3");
for(Iterator<String> iter=set.iterator();iter.hasNext();)

{

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

}
}
}

HashSet类

用HashSet过滤自定义类。一般认为如果学号一致，就应该是同一个人。本例的过 滤规则就是同学号的学生将保留一个。

import java.util.HashSet;
import java.util.Iterator;
class Student {

private String num;
private String name;

Student(String num,String name)    {

this.num=num;

this.name=name;
}

public String getNum() {
return num;
}

public void setNum(String num) {

this.num = num;
}

public String getName() {
return name;
}

public void setName(String name) {

this.name = name;
}

public String toString() {
return "学号是"+num+"姓名是"+name;

}

public int hashCode() {

return this.getNum().hashCode();

}

public boolean equals(Object obj) {

Student stu=(Student) obj;

if(this.getNum()==stu.getNum()){
return true;

}

return false;
}
}

public class TestStudent {

public static void main(String[] args) {

HashSet<Student> set=new HashSet<Student>();

Student s1=new Student("13","李四");

Student s2=new Student("12","张三");

Student s3=new Student("12","w");

Student s4=new Student("11","f");

set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
//问题1：如何打印出来就是姓名+学号这种形式呢？
//问题2：set中存储的对象如果hashCode一致，就认为是一个对象
//只要对象学号的hasCode一致，set进行自动过滤
//iter.next()进行对象实例化时，会自动调用类中隐藏的方法
for(Iterator<Student> iter=set.iterator();iter.hasNext();)

{
System.out.println(iter.next());
}
}
}

LinkedHashSet的用法  LinkedHashSet是HashSet的子类，用法和HashSet一致

import java.util.Iterator;
import java.util.LinkedHashSet;

public class LinkedHashSetTest {
/**
* 存储有序对象先进先出
*/

public static void main(String[] args) {

LinkedHashSet<String> set=new LinkedHashSet<String>();

set.add("1");
set.add("2");
set.add("3");
set.add("4");

for(Iterator<String> iter=set.iterator();iter.hasNext();)

System.out.println(iter.next());
}
}

Map接口

Map接口不是Collection接口的继承。Map接口用于维护键/值对(key/value pairs)。   该接口描述了从不重复的键到值的映射。
实现Map接口的类用来存储键－值 对。

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

Map类中存储的键－值对通过键来标识，所以键值不能重复

Map 接口方法  

Object put(Object key, Object value); 

Object get(Object key); Object remove(Object key);  

boolean containsKey(Object key); 

boolean containsValue(Object value);

import java.util.HashMap;
import java.util.Iterator;

public class Student {

private String name;

private String className;

public Student(String name,String className)  {

this.name=name;

this.className=className;
}

public String getName() {
return name;
}

public void setName(String name) {

this.name = name;
}

public String getClassName() {

return className;

}

public void setClassName(String className) {

this.className = className;
}

public String toString() {

// TODO Auto-generated method stub

return this.className;
}

public static void main(String arge[])  {

Student s1=new Student("rose","c1");

Student s2=new Student("jack","c2");

HashMap<Student, String> hm=new HashMap<Student, String>();

hm.put(s1, "rose");
hm.put(s2, "jack");

for(Iterator<Student> iter=hm.keySet().iterator();iter.hasNext();)   {

Student s=(Student)iter.next();

System.out.println(s+""+hm.get(s));
}

}
}

第一步，确定存储方式   

1、Map接口用于维护“键-值对”的关联性，可以通过键查找值 

2、HashMap是Map接口的一个具体实现类

import java.util.HashMap;
import java.util.Iterator;
public class MapTest {
public static void main(String[] args) {

HashMap<String,String> map=new HashMap<String,String>();
map.put("001","aaaaaaaaaa");

map.put("002","bbbbbbbbbbbb");

map.put("003","cccccccccccccc");

System.out.println(map.get("001"));

//先把HashMap转换成Set接口，再通过接口的相应方法遍历

for(Iterator<String> iter=map.keySet().iterator();iter.hasNext();)

{

String key=(String)iter.next();
System.out.println(key+""+map.get(key));

}      //如果说map里面包含001的键值

if(map.containsKey("001")){

System.out.println("有此键值");   }

else{

System.out.println("无此键值");

}

}
}

总结：

Java的集合框架分别派生自Collection和Map接口。

 Collection有两个常用子接口List和Set，分别表示有序可重复，无序不可重复的集合。