一、集合类
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
集合类与数组的区别：
集合的特点：1. 长度可变；2. 只能储存类类型；3. 可以储存不同类型的对象。
数组特点：1.长度固定；2.用于存放基本类型的数据；3.只能存储同一类型的基本类型数据。
二、Collection
Collection是集合框架中的常用接口。Collection接口为层次结构的根接口。构成Collection的单位被称为元素。其下有两个子接口：List（列表），Set（集）。
所属关系：
Collection
|--List//元素是有序的，元素可以重复。因为该集合体系有索引。
|--Set//元素是无序的，元素不可以重复。
方法如下：
1、添加元素
//add方法的参数类型是Object。以便于接收任意类型对象。
2、删除元素
remove(Object obj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3、判断元素
(Object obj);//判断是否存在obj这个元素
isEmpty();//是否为空
4、获取个数，集合长度
size();
5、取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。例子
package com.itheima;
import java.util.*;
public class Test2 {
public static void main(String[] args) {
Collection<String> list = new ArrayList<String>(); //创建ArrayList对象
list.add("Element1");
list.add("Element2");
list.add("Element3");
list.add("Element4");
list.add("Element5");//依次使用Collection的add方法添加元素
for(String str: list){ //遍历对象
System.out.println(str);
}
}
}
三、迭代器
1、概述
迭代是取出集合中元素的一种方式。
2、迭代的常见操作
hasNext();//有下一个元素，返回真
next();//取出下一个元素
remove();//移除注：在迭代时循环中next调用一次，就要hasNext判断一次。
3、迭代注意事项
迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
迭代器的next方法返回值类型是Object，所以要记得类型转换。
示例代码：
package collectionExam;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Collection<String> collection = new ArrayList<>();
collection.add("name1");
collection.add("name2");
collection.add("name3");
Iterator<String> iterator = collection.iterator();
while(iterator.hasNext())
{
String name = (String)iterator.next();
System.out.println(name);
}
}
}四、List
List的子类
List：元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
List的特有方法
1、增
boolean add(index,element);//指定位置添加元素
Boolean addAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素
2、删
Boolean remove(index);//删除指定位置的元素
3、改
set(index,element);//修改指定位置的元素。
4、查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5、其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。
<span style="font-size:10px;">package collectionExam;
import java.util.ArrayList;
import java.util.List;
public class CollectionDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
List<String> collection = new ArrayList<>();
collection.add("name1");
collection.add("name2");
collection.add("name3");
collection.set(0,"changename");
System.out.println("List的index0位置的值为："+collection.get(0));
//修改0角标的元素值，并打印
collection.remove(0);
for(int index =0;index<collection.size();index++)
{
System.out.println("位置"+index+"的值为"+collection.get(index));
}
}
}</span>五、ListIterator
1、概述
ListIterator是List集合特有的迭代器，是Iterator的子接口。
2、ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
六、LinkedList
LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
特有方法：
1、增
offFirst();
offLast();
2、获取
//获取元素，但是不删除。如果集合中没有元素，会返回null。
peekFirst();
peekLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
示例：
import java.util.*;
class LinkedListTest
{
public static void main(String[] args)
{
LinkedList l=new LinkedList();
l.addFirst("java01");
l.addFirst("java02");
l.addFirst("java03");
l.addFirst("java04");
l.addFirst("java05");
//堆栈输出
// stack(l);
//队列输出
queue(l);
}
//堆栈
public static void stack(LinkedList l)
{
while (!l.isEmpty())
{
sop(l.removeFirst());
}
}
//队列
public static void queue(LinkedList l)
{
while(!l.isEmpty())
{
sop(l.removeLast());
}
}
//输出
public static void sop(Object obj)
{
System.out.println(obj);
}
} 七、Set
概述
Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。
HashSet
HashSet：线程不安全，存取速度快。
可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
示例：
package com.itheima;
import java.util.*;
class PersonHashSet{
private String name;
private int age;
public PersonHashSet(String name,int age){
this.name = name;
this.age = age;
}
//重写PersonHashSet类的hashCode方法
public int hashCode(){
return name.hashCode()+age;
}
//重写PersonHashCode类的equals方法
public boolean equals(Object obj)
{
if(obj instanceof PersonHashSet)
{
PersonHashSet person = (PersonHashSet)obj;
if(this.name.equals(person.name)&&this.age == person.age)
return true;
}
return false;
}
public void show(){
System.out.println("name="+name+" "+"age="+age);
}
}
public class HashSetDemo {
public static void main(String[] args) {
HashSet<PersonHashSet> hashSets = new HashSet<>();
hashSets.add(new PersonHashSet("zhangsan", 33));
hashSets.add(new PersonHashSet("lisi", 30));
hashSets.add(new PersonHashSet("wangwu", 18));
for(PersonHashSet p :hashSets)
{
p.show();
}
}
}三、TreeSet
1、特点
a、底层的数据结构为二叉树结构（红黑树结构）
b）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。
java中的很多类都具备比较性，其实就是实现了Comparable接口。
注意：排序时，当主要条件相同时，按次要条件排序。
c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。
2、Tree排序的两种方式
1）第一种排序方式：自然排序
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。
示例：
package com.itheima;
import java.util.*;
//TreeSet集合必须预先实现Comparable接口
class PersonTreeSet implements Comparable{
private String name;
private int age;
public PersonTreeSet(String name,int age){
this.name = name;
this.age = age;
}
public int compareTo(Object o) {
PersonTreeSet person = (PersonTreeSet)o;
if(this.name.hashCode()>person.name.hashCode())
{
return 1;
}
else if(this.name.hashCode()<person.name.hashCode())
{
return -1;
}
else
{
if(this.age>person.age)
return 1;
else if(this.age<person.age)
return -1;
else return 0;
}
}
public void show(){
System.out.println("name="+name+" "+"age="+age);
}
}
public class PersonTreeSetDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
TreeSet<PersonTreeSet> treeSets = new TreeSet<>();
treeSets.add(new PersonTreeSet("zhangsan", 33));
treeSets.add(new PersonTreeSet("lisi", 30));
treeSets.add(new PersonTreeSet("wangwu", 18));
for(PersonTreeSet p :treeSets)
{
p.show();
}
}
}2）第二种方式：比较器
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
当两种排序都存在时，以比较器为主。
示例：
package com.itheima;
import java.util.*;
class PersonDemo implements Comparable<Object>{
private String name;
private int age;
public PersonDemo(String name,int age){
this.name = name;
this.age = age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public int compareTo(Object obj){
if(obj instanceof PersonDemo){
PersonDemo p = (PersonDemo)obj;
if(this.name.hashCode()<p.name.hashCode())
return -1;
else if(this.name.hashCode()>p.name.hashCode())
return 1;
}
return 0;
}
public void show(){
System.out.println(this.name +":"+this.age);
}
}
class MyCompare implements Comparator<PersonDemo>{
public int compare(PersonDemo p1,PersonDemo p2){
if(p1.getAge()>p2.getAge()){
return 1;
}
else if(p1.getAge()<p2.getAge())
return -1;
else {
return 0;
}
}
}
public class PersonTreeSetDemo2{
public static void main(String[] args){
TreeSet<PersonDemo> treeSets = new TreeSet<>(new MyCompare());
treeSets.add(new PersonDemo("zhangsan",23));
treeSets.add(new PersonDemo("lisi", 34));
treeSets.add(new PersonDemo("anni", 11));
treeSets.add(new PersonDemo("alex", 45));
for(PersonDemo p:treeSets)
{
p.show();
}
}
}四、Map集合
1、简述：
Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）
2、特点：
1）该集合存储键值对，一对一对往里存
2）要保证键的唯一性。
3、Map集合的子类
Map
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。
|--HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
1、添加
put(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。
voidputAll(Map <? extends K,? extends V> m);//添加一个集合
2、删除
clear();//清空
remove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
get(Object key);//通过键获取对应的值
size();//获取集合的长度
Collection<V>value();//获取Map集合中所以得值，返回一个Collection集合
还有两个取出方法，接下来会逐个讲解：
Set<Map.Entry<K,V>>entrySet();
Set<K> keySet();
注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。4、Map集合的两种取出方式
Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。
1、Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取每一个键对应的值。
示例：
/*
每一个学生都有对应的归属地。
学生Student，地址String。
学生属性：姓名，年龄。
注意：姓名和年龄相同的视为同一个学生。
保证学生的唯一性。
思路：1、描述学生类
2、定义一个Map集合，存储学生对象和地址值
3、获取Map中的元素
*/
import java.util.*;
//描述学生类
class Student implements Comparable<Student>
{
private String name;
private int age;
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//复写hashCode
public int hashCode()
{
return name.hashCode()+age*33;
}
//复写equals，比较对象内容
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student s=(Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
//复写compareTo,以年龄为主
public int compareTo(Student c)
{
int num=new Integer(this.age).compareTo(new Integer(c.age));
if(num==0)
{
return this.name.compareTo(c.name);
}
return num;
}
//复写toString，自定义输出内容
public String toString()
{
return name+"..."+age;
}
}
class HashMapTest
{
public static void main(String[] args)
{
HashMap<Student,String > hm=new HashMap<Student,String >();
hm.put(new Student("zhangsan",12),"beijing");
hm.put(new Student("zhangsan",32),"sahnghai");
hm.put(new Student("zhangsan",22),"changsha");
hm.put(new Student("zhangsan",62),"USA");
hm.put(new Student("zhangsan",12),"tianjing");
keyset(hm);
}
//keySet取出方式
public static void keyset(HashMap<Student,String> hm)
{
Iterator<Student> it=hm.keySet().iterator();
while(it.hasNext())
{
Student s=it.next();
String addr=hm.get(s);
System.out.println(s+":"+addr);
}
}
} 2 、 Set<Map.Entry<K,V>> entrySet() ：将 Map 集合中的映射关系存入到 Set 集合中，而这个关系的数据类型就是： Map.Entry
其实，Entry也是一个接口，它是Map接口中的一个内部接口。
示例：
同上面示例的学生类----
class HashMapTest
{
public static void main(String[] args)
{
HashMap<Student,String > hm=new HashMap<Student,String >();
hm.put(new Student("zhangsan",12),"beijing");
hm.put(new Student("zhangsan",32),"sahnghai");
hm.put(new Student("zhangsan",22),"changsha");
hm.put(new Student("zhangsan",62),"USA");
hm.put(new Student("zhangsan",12),"tianjing");
entryset(hm);
}
//entrySet取出方式
public static void entryset(HashMap<Student,String> hm)
{
Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator();
while(it.hasNext())
{
Map.Entry<Student,String> me=it.next();
Student s=me.getKey();
String addr=me.getValue();
System.out.println(s+":::"+addr);
}
}
} 关于Map.Entry：
Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？
原因：a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。
Map的小应用：
/*
思路：1、将字符串转换为字符数组
2、定义一个TreeMap集合，用于存储字母和字母出现的次数
3、用数组去遍历集合，如果集合中有该字母则次数加1，如果集合中没有则存入
4、将TreeMap集合中的元素转换为字符串
*/
package TreeMapTest;
import java.util.*;
class CharCount
{
public static void main(String[] args)
{
String s="sdfgzxcvasdfxcvdf";
System.out.println("s中各字母出现的次数："+charCount(s));
}
//定义一个方法获取字符串中字母出现的次数
public static String charCount(String str)
{
char[] cha=str.toCharArray();//转换为字符数组
//定义一个TreeMap集合，因为TreeMap集合会给键自动排序
TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
int count=0;//定义计数变量
for (int x=0;x<cha.length ;x++ )
{
if(!(cha[x]>='a'&&cha[x]<='z'||cha[x]>='A'&&cha[x]<='Z'))
continue;//如果字符串中非字母，则不计数
Integer value=tm.get(cha[x]);//获取集合中的值
if(value!=null)//如果集合中没有该字母，则存入
count=value;
count++;
tm.put(cha[x],count);//存入键值对
count=0;//复位计数变量
}
StringBuilder sb=new StringBuilder();//定义一个容器
//遍历集合，取出并以题目格式存入容器中
for(Iterator<Character> it=tm.keySet().iterator();it.hasNext();)
{
Character ch=it.next();
Integer value=tm.get(ch);
sb.append(ch+"("+value+")");
}
return sb.toString();//返回字符串
}
} 
扫一扫
619
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
