java容器的输出_java容器---集合总结

最新推荐文章于 2021-11-19 21:13:22 发布
最新推荐文章于 2021-11-19 21:13:22 发布
阅读量202 收藏
点赞数
文章标签： java容器的输出
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_32537029/article/details/114112925
版权

思考为什么要引入容器这个概念？

Java有多种方式保存对象(应该是对象的引用)，例如使用数组时保存一组对象中的最有效的方式，如果你想保存一组基本类型的数据，也推荐使用这种方式，但大家知道数组是具有固定尺寸的，你必须事先知道你要需要多少个对象。但是在一般的情况中，你在写程序中并不知道将需要多少个对象，或者是否需要更加复杂的方式来存储对象，因此数组尺寸固定很不爽！

为了解决上述问题，引入了容器的概念。容器提供了完善的方法来保存对象，你可以使用这些工具来解决数量惊人的问题。Java容器类可以自动调整自己的尺寸，因此与数组不同，你可以将任意数量的对象放到容器中，并不担心容器设置为多大。

KmvdvnSLX6W41HCwEAx8GjhQCAkdKtEAAAbtEKAQAoEUIAAEqEEACAEiEEAKBECAEAKP0XmZr4PqjP+nUAAAAASUVORK5CYII=

集合特点：

1，用于存储对象的容器。

2，集合的长度是可变的。

3，集合中不可以存储基本数据类型值。

java容器类库用途是保存对象。分为2类：

1. Collection

一个独立元素的序列，这些元素都服从一条或多条规则。List必须按照插入的顺序保存元素，Set不能有重复元素。Queue按照排队规则来确定对象产生的顺序(通常与插入的顺序相同)。

2. Map

一组成对的键值对对象，允许使用键来查找值，将数字和对象关联到一起。映射表允许我们使用另一个对象来查找某个对象，也被称为关联数组或字典。Map很强大

List类型

List接口在Collection的基础上添加了大量的方法，使得可以在List中间插入和移除元素。

1 ArrayList和 LinkedList

都按照被插入的顺序保存元素，区别在于执行某些操作时的性能。且LinkedList包含的操作也多于ArrayList.

(1)ArrayList  ：优势随机访问元素比较快，有连续的数组空间，但是在List的中间插入和移除元素时较慢，需要大量的移动内部的元素。

你可以把ArrayList  当做“可以自动扩充自身的数组”来看待，使用ArrayList也相当简单：创建一个实例，用add()插入对象；然后用get()访问这些对象，此时需要索引，就像数组一样，但是不需要方括号。ArrayList还有一个size()方法，使你知道有多少个元素添加进来，从而不会不小心因索引越界而引发错误。

(2)LinkedList：在LinkedList中间插入删除较快，提供优化的顺序访问。随机访问时较慢，特性集较ArrayList  大。各种Queue以及栈的行为，由LinkedList提供支持。

Set类型

1.HashSet TreeSet LinkedHashSet

输出显示在Set中，每个相同的项只保存一次，但存储的方式不同：

(1)  Hashset存储方式复杂，但保证了最快的获取速度

(2)TreeSet按照升序保存对象

(3)LinkedHashSet按照添加的顺序保存对象

Map

可以使用键来查找对象，类似于数组下标。Map.put(key,value)插入数据，Map.get(key)查找数据。键要求唯一。存储方式不是顺序存储，速度快。不必指定Map的尺寸，因为它自己会自动的调整。

(1)HashMap使用最快的查找技术，存储无顺序。

(2)TreeMap按照比较结果升序保存。

(3)LinkedHashMap按照插入顺序保存键，同时保留HashMap的查询速度。

迭代器(也是一种设计模式)

容器缺点：使用容器，必须对容器的确切类型进行编程，但若像更换或扩展至其他容器，必须重写代码。迭代器可以解决这个问题，实现代码的重用。它是一个对象，它的工作是遍历并选择序列中的对象，而客户端程序员不必知道或关心该序列底层的结构。它是轻量级对象，创建的代价小。

因此经常对迭代器有些奇怪的限制：

1)使用方法Iterator()要求容器返回一个Iterator。Iterator将准备好返回序列中的第一个元素。

2)使用next()获得序列的下一个元素。

3)使用hasNext()检查序列中是否还有元素。

4)使用remove()将迭代器新近返回的元素删除。

迭代器能够将遍历序列的操作与序列底层的结构分离，它统一了对容器的访问方式，这是它的威力所在。

框架的顶层Collection接口：

Collection的常见方法：

1，添加。

boolean add(Object obj):

boolean addAll(Collection coll):

2，删除。

boolean remove(object obj):

boolean removeAll(Collection coll);

void clear();

3，判断：

boolean contains(object obj):

boolean containsAll(Colllection coll);

boolean isEmpty():判断集合中是否有元素。

4，获取：

int size():

Iterator iterator():取出元素的方式：迭代器。

该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。

所以该迭代器对象是在容器中进行内部实现的。

对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，

也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

5，其他：

boolean retainAll(Collection coll);取交集。

Object[] toArray():将集合转成数组。

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p3.collection.demo;

import java.util.ArrayList;

import java.util.Collection;

public class CollectionDemo {

/**

* @param args

*/

public static void main(String[] args) {

/*Collection coll = new ArrayList();

show(coll);

*/

Collection c1 = new ArrayList();

Collection c2 = new ArrayList();

show(c1,c2);

}

public static void show(Collection c1,Collection c2){

//给c1添加元素。

c1.add("abc1");

c1.add("abc2");

c1.add("abc3");

c1.add("abc4");

//给c2添加元素。

c2.add("abc2");

c2.add("abc5");

c2.add("abc6");

System.out.println("c1:"+c1);//c1:[abc1, abc2, abc3, abc4]

System.out.println("c2:"+c2);//c2:[abc2, abc5, abc6]

//将c2中的元素添加到c1集合中,添加一堆

c1.addAll(c2);

System.out.println(c1);//[abc1, abc2, abc3, abc4, abc2, abc5, abc6]

//演示removeAll

//将两个集合中的相同元素从调用removeAll的集合中删除,从c1中删除c1和c2相同的元素

/* boolean b = c1.removeAll(c2);

System.out.println("removeAll:"+b);

System.out.println("c1"+c1);//c1[abc1, abc3, abc4]

*/

//演示containsAll，c1集合中是否包含C2中的所有元素，包含返回true

boolean b1 = c1.containsAll(c2);

System.out.println("containsAll:"+b1);

//演示retainAll 取交集，保留和指定的集合相同的元素，而删除不同的元素。和removeAll功能相反 。

//c2:[abc2, abc5, abc6],

//addAll后的C1:[abc1, abc2, abc3, abc4, abc2, abc5, abc6]

// boolean b = c1.retainAll(c2);

// System.out.println("retainAll:"+b);

// System.out.println("c1:"+c1);//c1:[abc2, abc2, abc5, abc6]

}

/**

* 测试集合 Collection集合中的方法

* @param coll

*/

public static void show(Collection coll){

//1,添加元素。add.

coll.add("abc1");

coll.add("abc2");

coll.add("abc3");

System.out.println(coll);

//2，删除元素。remove

if(coll.contains("abc2")){

coll.remove("abc2");//会改变集合的长度

}

//清空集合

//coll.clear();//清空集合中的元素，但是集合还在，集合为[]空

System.out.println(coll.contains("abc3"));

System.out.println(coll);

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

Collection集合的遍历：使用Iterator

48304ba5e6f9fe08f3fa1abda7d326ab.png

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class IteratorDemo {

/**

* java.util.NoSuchElementException

*/

public static void main(String[] args) {

Collection coll = new ArrayList();

coll.add("abc1");

coll.add("abc2");

coll.add("abc3");

coll.add("abc4");

System.out.println(coll);//[abc1, abc2, abc3, abc4]

//使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。

Iterator it = coll.iterator();

while(it.hasNext()){

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

}

/* for(Iterator it = coll.iterator(); it.hasNext(); ){

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

}*/

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

Collection

|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。

|--Set：元素不能重复,无序。

48304ba5e6f9fe08f3fa1abda7d326ab.png

import java.util.ArrayList;

import java.util.List;

/**

*

List:特有的常见方法：有一个共性特点就是都可以操作角标。

1，添加

void add(index,element);

void add(index,collection);

2，删除；

Object remove(index):

3，修改：

Object set(index,element);

4，获取：

Object get(index);

int indexOf(object);获取指定元素的索引

int lastIndexOf(object);

List subList(from,to);

*

*

*/

public class ListDemo {

/**

* @param args

*/

public static void main(String[] args) {

List list = new ArrayList();

show(list);

}

public static void show(List list) {

//添加元素

list.add("abc1");

list.add("abc2");

list.add("abc3");

System.out.println(list);//[abc1, abc2, abc3]

//插入元素,在列表的指定位置插入元素

list.add(1,"abc9");

System.out.println(list);//[abc1, abc9, abc2, abc3]

//删除元素。

System.out.println("remove:"+list.remove(2));//remove:abc2

//修改元素。

System.out.println("set:"+list.set(1, "abc8"));//set:abc9

//获取元素。

System.out.println("get:"+list.get(0));//get:abc1

System.out.println(list);//[abc1, abc8, abc3]

//获取子列表。

System.out.println("sublist:"+list.subList(1, 3));//sublist:[abc8, abc3]

//根据对象获取位置

System.out.println(list.indexOf("abc8"));//1

System.out.println(list.lastIndexOf("abc3"));//2

System.out.println(list);//[abc1, abc8, abc3]

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

List的遍历方式以及使用，使用Iterator接口的子接口ListIterator来完成在迭代中对集合元素进行的增删改查，不会抛出并发修改的异常

48304ba5e6f9fe08f3fa1abda7d326ab.png

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

public class ListDemo2 {

/**

* @param args

*/

public static void main(String[] args) {

List list = new ArrayList();

showListIterator(list);

}

/**

* 可以使用Iterator接口的子接口ListIterator来完成在迭代中对集合元素进行的增删改查，不会抛出并发修改的异常

* 线程只操作迭代对象，不修改集合，这就不是并发的操作，是迭代对象ListIterator中自己的增删改方法，而不是调用集合中的方法

* @param list

*/

public static void showListIterator(List list){

list.add("abc1");

list.add("abc2");

list.add("abc3");

list.add("abc4");

list.add("abc5");

System.out.println("list:"+list);

ListIterator it = list.listIterator();

while(it.hasNext()){

Object obj = it.next();

if(obj.equals("abc4")){

//it.add("abc9");//不是list.add

it.set("abc9");

}

else

System.out.print(" "+obj);

}

System.out.print("\n");

System.out.println("********************************");

//System.out.println("hasnext:"+it.hasNext());

//System.out.println("hasPrevious:"+it.hasPrevious());

//System.out.println("previous:"+it.previous());

//逆向遍历

while(it.hasPrevious()){

System.out.print(" "+it.previous());//输出 abc5 abc9 abc3 abc2 abc1

}

System.out.print("\n");

System.out.println("********************************");

System.out.println(list);

}

/**

* java.util.ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常

* 集合和迭代器同时对元素进行修改，就会产生异常，一个线程对collection集合迭代，另一个对Collection进行修改的时候，

* 就会出现上面的异常

* @param list

*/

public static void showConcurrentModificationException(List list){

list.add("abc1");

list.add("abc2");

list.add("abc3");

System.out.println("list:"+list);

Iterator it = list.iterator();

while(it.hasNext()){

Object obj = it.next();//java.util.ConcurrentModificationException

//在迭代器过程中，不要使用集合操作元素，容易出现异常。

//可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。

if(obj.equals("abc2")){

list.add("abc9");

}

else

System.out.println("next:"+obj);

}

System.out.println(list);

}

/**

* List集合的遍历，下面两种方法都可以

* @param list

*/

public static void show(List list) {

list.add("abc1");

list.add("abc2");

list.add("abc3");

list.add("abc4");

//第一种使用iterator

Iterator it = list.iterator();

while(it.hasNext()){

System.out.println("next:"+it.next());

}

//list特有的取出元素的方式之一。

for(int x=0; x

System.out.println("get:"+list.get(x));

}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

List:

|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！

|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。

|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

Vector：

48304ba5e6f9fe08f3fa1abda7d326ab.png

import java.util.Enumeration;

import java.util.Iterator;

import java.util.Vector;

public class VectorDemo {

/**Enumeration枚举接口的功能和Iterator迭代器接口的功能是重复的，Iterator接口添加了一个可选的移除方法，并使用较短的方法名

* java1.2开始，使用Iterator替代Enumeration

* @param args

*/

public static void main(String[] args) {

Vector v = new Vector();

v.addElement("abc1");

v.addElement("abc2");

v.addElement("abc3");

v.addElement("abc4");

Enumeration en = v.elements();

while(en.hasMoreElements()){

System.out.println("nextelment:"+en.nextElement());

}

Iterator it = v.iterator();

while(it.hasNext()){

System.out.println("next:"+it.next());

}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

ArrayList

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p.bean;

public class Person {

private String name;

private int age;

public Person() {

super();

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String toString(){

return name+":"+age;

}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

48304ba5e6f9fe08f3fa1abda7d326ab.png

import java.util.ArrayList;

import java.util.Iterator;

import cn.itcast.p.bean.Person;

public class ArrayListTest {

/**

* @param args

*/

public static void main(String[] args) {

ArrayList al = new ArrayList();

al.add(new Person("listP1",21));

al.add(new Person("listP1",22));

al.add(new Person("listP2",23));

al.add(new Person("listP3",24));

System.out.println(al);//[listP1:21, listP1:22, listP2:23, listP3:24]

Iterator it = al.iterator();

while(it.hasNext()){

Person p = (Person) it.next();

System.out.println(p.getName()+"--"+p.getAge());

}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

输出：

[listP1:21, listP1:22, listP2:23, listP3:24]

listP1--21

listP1--22

listP2--23

listP3--24

LinkedList:

addFirst();

addLast():

jdk1.6

offerFirst();

offetLast();

getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.

getLast();

jdk1.6

peekFirst();//获取但不移除，如果链表为空，返回null.

peekLast():

removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.

removeLast();

jdk1.6

pollFirst();//获取并移除，如果链表为空，返回null.

pollLast();

48304ba5e6f9fe08f3fa1abda7d326ab.png

import java.util.Iterator;

import java.util.LinkedList;

public class LinkedListDemo {

/**

* @param args

*/

public static void main(String[] args) {

LinkedList link = new LinkedList();

link.addFirst("abc1");

link.addFirst("abc2");

link.addFirst("abc3");

link.addFirst("abc4");

System.out.println(link);

System.out.println("使用getFirst---"+link.getFirst());//获取第一个但不删除。当链表为空的时候会抛出抛出NoSuchElementException

System.out.println("使用getLast---"+link.getLast());//获取最后一个元素，当链表为空的时候会抛出抛出NoSuchElementException

System.out.println("使用peekFirst---"+link.peekFirst());//获取第一个元素，当链表为为空的时候不会报异常

System.out.println("使用peekLast---"+link.peekLast());//获取最后一个元素

// System.out.println("使用link.removeFirst---"+link.removeFirst());//获取第一个元素但是会删除。abc4，当链表为空的时候会抛出抛出NoSuchElementException

// System.out.println("使用removeFirst---"+link.removeFirst());//abc3

// System.out.println("使用removeLast---"+link.removeLast());//获取最后一个元素，并移除abc1

System.out.println("使用pollFirst---"+link.pollFirst());//获取第一个元素并从集合中移除(1.6，出来的新方法，当链表为为空的时候不会报异常)

System.out.println("使用pollFirst---"+link.pollFirst());

System.out.println("使用pollLast---"+link.pollLast());//获取最后一个元素并从集合中移除

System.out.println("使用pollLast---"+link.pollLast());

// while(!link.isEmpty()){

// System.out.println(link.removeLast());

// }

System.out.println(link);

// Iterator it = link.iterator();

// while(it.hasNext()){

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

// }

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

Set:元素不可以重复，是无序。

Set接口中的方法和Collection一致。

|--HashSet: 内部数据结构是哈希表 ，是不同步的。

如何保证该集合的元素唯一性呢？

是通过对象的hashCode和equals方法来完成对象唯一性的。

如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。

如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。

如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。

一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。

建立对象判断是否相同的依据。

如果HashSet不覆盖equal和hashCode方法的话，默认的是使用Object中的equal和hashCode方法

Object中的equal方法比较地址的，而不是比较内容，如果添加重复的对象，地址不同，就会认为没有重复的对象

所以比较对象是否相同，必须覆盖equal和hashCode方法

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p.bean;

public class Person /*extends Object*/ {

private String name;

private int age;

public Person() {

super();

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String toString(){

return name+":"+age;

}

@Override

public boolean equals(Object obj) {//判断人的内容是否相同

System.out.println("调用了equals方法---------------");

if(this == obj) //this只是否为Person对象

return true;

if(!(obj instanceof Person)){

throw new ClassCastException("类型转化错误！");

}

Person p = (Person)obj;

return this.name.equals(p.name) && this.age == p.age;//字符创name的内容相同吗

}

@Override

public int hashCode() { //判断人的hash值是否相同

System.out.println("调用了hashCode方法---------------");

return name.hashCode()+ age;

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

往hashSet里面添加元素，进行遍历：

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p4.hashset.test;

import java.util.HashSet;

import java.util.Iterator;

import cn.itcast.p.bean.Person;

/*

* 往hashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人。视为相同元素。

*/

public class HashSetTest {

/**

* @param args

*/

public static void main(String[] args) {

HashSet hs = new HashSet();

/*

* HashSet集合数据结构是哈希表，所以存储元素的时候，我们需要覆盖hashCode方法和equal方法，来确保放入的对象的唯一性

* 使用的元素的hashCode方法来确定位置，如果位置相同，

* 在通过元素的equals来确定是否相同,如果相同的话，就不往set里面存

*/

hs.add(new Person("lisi4",24));

hs.add(new Person("lisi7",27));

hs.add(new Person("lisi1",21));

hs.add(new Person("lisi9",29));

hs.add(new Person("lisi7",27));

Iterator it = hs.iterator();

while(it.hasNext()){

Person p = (Person)it.next();

//System.out.println(p);

System.out.println(p.getName()+"...."+p.getAge());

}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

输出：

调用了hashCode方法---------------

调用了hashCode方法---------------

调用了hashCode方法---------------

调用了hashCode方法---------------

调用了hashCode方法---------------

调用了equals方法---------------

lisic....21

lisia....24

lisid....29

lisib....27

结果说明调用了5次hashCode，调用了一次equals方法，说明当执行到这句话的时候，hs.add(new Person("lisi7",27));调用了equal方法，因为hash表里面已经有了一个name为lisi7，年龄为27的对象，hash值相同，需要判断内容是否相同，调用equal方法判断内容是否相同，相同，不往hashset里面存储。

TreeSet

自然排序，如果存放的是自定义对象，使用TreeSet，必须实现Comparable接口，覆盖里面的compareTo方法，添加元素的时候进行比较；如果添加的是字符串

就不需要覆盖compareTo方法，因为字符串有自己的compareTo方法；

自定义对象在TreeSet存储时候，如果不覆盖，就会报 java.lang.ClassCastException: cn.itcast.p.bean.Person cannot be cast to java.lang.Comparable异常

48304ba5e6f9fe08f3fa1abda7d326ab.png

public class Person /*extends Object*/ implements Comparable{

private String name;

private int age;

public Person() {

super();

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String toString(){

return name+":"+age;

}

@Override

public boolean equals(Object obj) {//判断人的内容是否相同

System.out.println("调用了equals方法---------------");

if(this == obj) //this只是否为Person对象

return true;

if(!(obj instanceof Person)){

throw new ClassCastException("类型转化错误！");

}

Person p = (Person)obj;

return this.name.equals(p.name) && this.age == p.age;//字符创name的内容相同吗

}

@Override

public int hashCode() { //判断人的hash值是否相同

System.out.println("调用了hashCode方法---------------");

return name.hashCode()+ age;

}

@Override

public int compareTo(Object o) {

if(!(o instanceof Person))

throw new ClassCastException("类型转化错误");

Person p = (Person)o;

int temp = this.age-p.age;

return temp==0 ? (this.name.compareTo(p.name)) : temp;//temp等于0表示年龄相等。

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

import java.util.Iterator;

import java.util.TreeSet;

import cn.itcast.p.bean.Person;

public class TreeSetDemo {

/**

* @param args

*/

public static void main(String[] args) {

demo2();

}

/*

* 自定义对象，使用TreeSet，进行自然排序的时候，

* 需要实现Comparable接口，添加元素的时候进行比较,

* 以Person对象年龄进行排序，如果年龄相同，就按照姓名排序

*

*/

public static void demo2(){

TreeSet ts = new TreeSet();

ts.add(new Person("zhangsan",28));

ts.add(new Person("lisi",21));

ts.add(new Person("zhouqi",29));

ts.add(new Person("zhaoliu",25));

ts.add(new Person("wangu",24));

ts.add(new Person("zhouqi",29));

Iterator it = ts.iterator();

while(it.hasNext()){

Person p = (Person)it.next();

System.out.println(p.getName()+":"+p.getAge());

}

}

/**

* 添加的是字符串对象，因为字符串内部实现了compareTo方法，

* 所以不需要实现Comparable接口里面的

*/

public static void demo1() {

TreeSet ts = new TreeSet();

ts.add("abc");

ts.add("zaa");

ts.add("aa");

ts.add("nba");

ts.add("cba");

Iterator it = ts.iterator();

while(it.hasNext()){

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

}

}

}

输出结果：先以年龄进行排序，再以姓名进行排序。

lisi:21

wangu:24

zhaoliu:25

zhangsan:28

zhouqi:29

还可以使用Comparator super E> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。实现

48304ba5e6f9fe08f3fa1abda7d326ab.png

public class Person{

private String name;

private int age;

public Person() {

super();

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String toString(){

return name+":"+age;

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

Comparator比较器：

48304ba5e6f9fe08f3fa1abda7d326ab.png

import java.util.Comparator;

import cn.itcast.p.bean.Person;

/**

* 创建了一个根据Person类的name进行排序的比较器。

* 先按照姓名进行比较，如果姓名相同，再按照年龄进行比较

*/

public class ComparatorByName implements Comparator {

@Override

public int compare(Object o1, Object o2) {

Person p1 = (Person)o1;

Person p2 = (Person)o2;

int temp = p1.getName().compareTo(p2.getName());

//比较姓名相同，在比较年龄

return temp==0?p1.getAge()-p2.getAge(): temp;

// return 1;//有序。

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p5.treeset.demo;

import java.util.Iterator;

import java.util.TreeSet;

import cn.itcast.p.bean.Person;

import cn.itcast.p5.comparator.ComparatorByName;

public class TreeSetComparator {

/**

* @param args

*/

public static void main(String[] args) {

TreeSet ts = new TreeSet(new ComparatorByName());

/*

* 自定义对象，使用TreeSet，进行自然排序的时候，

* 需要实现Comparable接口，添加元素的时候进行比较

*

* 以Person对象年龄进行排序，如果年龄相同，就按照姓名排序

*

*/

ts.add(new Person("zhangsan",28));

ts.add(new Person("lisi",21));

ts.add(new Person("zhouqi",29));

ts.add(new Person("zhaoliu",25));

ts.add(new Person("wangu",24));

Iterator it = ts.iterator();

while(it.hasNext()){

Person p = (Person)it.next();

System.out.println(p.getName()+":"+p.getAge());

}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

输出：

lisi:21

wangu:24

zhangsan:28

zhaoliu:25

zhouqi:29

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p5.treeset.test;

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

import cn.itcast.p.bean.Person;

import cn.itcast.p5.comparator.ComparatorByLength;

/*

* 对字符串进行长度排序，比较内容

*

* "20 18 -1 89 2 67"

*/

public class TreeSetTest {

/**

* @param args

*/

public static void main(String[] args) {

//接口内部类

TreeSet ts = new TreeSet(new Comparator() {

@Override

public int compare(String o1, String o2) {

int temp = o1.length()-o2.length();

return temp==0 ? o1.compareTo(o2):temp;

}

});

ts.add("aaaaa");

ts.add("zz");

ts.add("nbaq");

ts.add("cba");

ts.add("abc");

ts.add("abc");

Iterator it = ts.iterator();

while(it.hasNext()){

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

}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

输出：

zz

abc

cba

nbaq

aaaaa

Map

48304ba5e6f9fe08f3fa1abda7d326ab.png

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

public class MapDemo {

public static void main(String[] args) {

Map map = new HashMap();

method(map);

}

/**

*

* Set> entrySet()方法：返回一个set集合，里面装的是Map.Entry接口类型的键值对象

*

* 第二种遍历map的方式：通过看API:Set> entrySet()：Map.Entry接口类型，

* 里面有K getKey() 返回与此项对应的键。 V getValue() 返回与此项对应的值。

* 思路：通过把map转化为set，进行迭代

* 通过使用entrySet方法吧键和值的映射关系作为对象，存储到set集合中，这个映射关系的类型为Map.Entry类型

*

*

*/

public static void method_3(Map map){

map.put(8,"lisi");

map.put(2,"zhaoliu");

map.put(7,"wangwu");

map.put(6,"wangwang");

Set>entrySet = map.entrySet();

System.out.println(entrySet);//[2=zhaoliu, 6=wangwang, 7=wangwu, 8=lisi]

Iterator>it = entrySet.iterator();

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

while(it.hasNext()){

Map.Entry entryMap = it.next();

Integer key = entryMap.getKey();//获取键

String value = entryMap.getValue();//获取值

System.out.println(key+":"+value);

}

}

/*

* 第一种遍历的方法

* Set keySet()：返回键的set集合

* 取出map中的所有元素。

* 原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，

在对每一个键通过map集合的get方法获取其对应的值即可。

*/

public static void method_2(Map map){

map.put(8,"zhaoliu");

map.put(2,"zhaoliu");

map.put(7,"xiaoqiang");

map.put(6,"wangcai");

Set keySet = map.keySet();

System.out.println(keySet);//键的set集合[2, 6, 7, 8]

Iterator it = keySet.iterator();//迭代keySet

while(it.hasNext()){

Integer key = it.next();

String value = map.get(key);

System.out.println(key+":"+value);

}

}

/**

* 常用方法：

1，添加。

value put(key,value):返回前一个和key关联的值，如果没有返回null.

2，删除。

void clear():清空map集合。

value remove(key):根据指定的key翻出这个键值对。

3，判断。

boolean containsKey(key):

boolean containsValue(value):

boolean isEmpty();

4，获取。

value get(key):通过键获取值，如果没有该键返回null。

当然可以通过返回null，来判断是否包含指定键。

int size(): 获取键值对的个数。

5.特殊方法： Collection values() 包含的值的 Collection 视图。

* @param map

*/

public static void method(Map map){//学号和姓名

// 添加元素。

System.out.println(map.put(8, null));//null

System.out.println(map.put(8, "xiaoqiang"));//wangcai 存相同键，值会覆盖。

map.put(2,"zhangsan");

map.put(7,"zhaoliu");

/*System.out.println(map);

//删除。

System.out.println("remove:"+map.remove(2));

//判断。

System.out.println("containskey:"+map.containsKey(6));

System.out.println("containsValue:"+map.containsValue("zhaoliu"));

//获取。

System.out.println("get:"+map.get(7));

System.out.println(map);*/

//返回key对应的所有value的集合

Collectionvalues = map.values();

System.out.println(values);

Iteratorit = values.iterator();

while(it.hasNext()){

String value = it.next();

System.out.println(value);

}

}

}

interface MyMap{

public static interface MyEntry{//内部接口

void get();

}

}

class MyDemo implements MyMap.MyEntry{

public void get(){}

}

class Outer{

static class Inner{

static void show(){}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

HashMap

48304ba5e6f9fe08f3fa1abda7d326ab.png

public class Person {

private String name;

private int age;

public Person() {

super();

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + age;

result = prime * result + ((name == null) ? 0 : name.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Person other = (Person) obj;

if (age != other.age)

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return "Person:"+getName()+":"+getAge();

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p2.bean;

public class Student extends Person {

public Student() {

super();

}

public Student(String name, int age) {

super(name, age);

}

@Override

public String toString() {

return "Student:"+getName()+":"+getAge();

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p7.hashmap.demo;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Set;

import cn.itcast.p2.bean.Student;

public class HashMapDemo {

/**

* @param args

*/

public static void main(String[] args) {

/*

* 将学生对象和学生的归属地通过键与值存储到map集合中。

*

*/

HashMap hm = new HashMap();

hm.put(new Student("lisi",38),"北京");

hm.put(new Student("zhaoliu",24),"上海");

hm.put(new Student("xiaoqiang",31),"沈阳");

hm.put(new Student("wangcai",28),"大连");

hm.put(new Student("zhaoliu",24),"铁岭");

// Set keySet = hm.keySet();

// Iterator it = keySet.iterator();

Iterator it = hm.keySet().iterator();

while(it.hasNext()){

Student key = it.next();

String value = hm.get(key);

System.out.println(key.getName()+":"+key.getAge()+"---"+value);

}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

结果：

xiaoqiang:31---沈阳

wangcai:28---大连

lisi:38---北京

zhaoliu:24---铁岭

HashMap要比较自定义对象也必须重写equal方法和hashCode方法。

TreeMap

排序，实现Comparator接口

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p3.comparator;

import java.util.Comparator;

import cn.itcast.p2.bean.Person;

public class ComparatorByName implements Comparator {

@Override

public int compare(Person o1, Person o2) {

int temp = o1.getName().compareTo(o2.getName());

return temp==0? o1.getAge()-o2.getAge(): temp;

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p8.treemap.demo;

import java.util.Iterator;

import java.util.Map;

import java.util.TreeMap;

import cn.itcast.p2.bean.Student;

import cn.itcast.p3.comparator.ComparatorByName;

public class TreeMapDemo {

/**

* @param args

*/

public static void main(String[] args) {

TreeMap tm = new TreeMap(new ComparatorByName());

tm.put(new Student("lisi",38),"北京");

tm.put(new Student("zhaoliu",24),"上海");

tm.put(new Student("xiaoqiang",31),"沈阳");

tm.put(new Student("wangcai",28),"大连");

tm.put(new Student("zhaoliu",24),"铁岭");

Iterator> it = tm.entrySet().iterator();

while(it.hasNext()){

Map.Entry me = it.next();

Student key = me.getKey();

String value = me.getValue();

System.out.println(key.getName()+":"+key.getAge()+"---"+value);

}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

输出结果：

lisi:38---北京

wangcai:28---大连

xiaoqiang:31---沈阳

zhaoliu:24---铁岭

LinkedHashMap

48304ba5e6f9fe08f3fa1abda7d326ab.png

package cn.itcast.p1.map.demo;

import java.io.File;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

public class LinkedHashMapDemo {

/**

* LinkedHashMap 按顺序存入，按顺序取出

*/

public static void main(String[] args) {

File f= null;

HashMap hm = new LinkedHashMap();

hm.put(7, "zhouqi");

hm.put(3, "zhangsan");

hm.put(1, "qianyi");

hm.put(5, "wangwu");

Iterator> it = hm.entrySet().iterator();

while(it.hasNext()){

Map.Entry me = it.next();

Integer key = me.getKey();

String value = me.getValue();

System.out.println(key+":"+value);

}

}

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

转载自：https://www.cnblogs.com/200911/p/3948436.html

徐轶青
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaSE基础知识(二十一)--Java集合(容器)之容器的打印输出
ruidianbaihuo的博客
10-26 345
Java SE 是什么，包括哪些内容(二十一)？ 本文内容参考自Java8标准 再次感谢Java编程思想对本文的启发！ 首先，了解一个方法： 类Arrays的方法toString()。 你必须使用类Arrays的方法toString()来产生数组的可打印表示 容器的打印无需任何的帮助，不需要特别使用哪个方法。 代码示例： // 容器的打印 //类PrintingContainers ...
java容器类知识点详细总结
08-25
Java 容器类知识点详细总结 Java 容器类是 Java 语言中的一种非常重要的数据结构，用于存储和管理对象的集合。Java 容器类可以分为四个主要部分：Collection、Map、Iterator 和子接口。 容器接口 容器接口是 Java...
java容器的输出_Java容器中的元素输出
weixin_39611308的博客
02-13 327
1、容器不同于数组，容器若是想输出全部元素，可以直接利用System.out.println(collection)public class TestCollectionArrayPrint {public static void main(String[] args){Collection collection = new ArrayList<>();collection.add("...
java容器的输出,Java中的容器
weixin_39863008的博客
03-22 73
array不论使用的array型别为何，array名称本身实际上是个reference，指向heap内的某个实际对象。这个对象持有“指向其它对象”的一些reference。这个对象可经由“array初始化语法”被自动产生，也可以以new表达式手动产生。array对象之内有个名为length的只读成员，它能够告诉array对象内的元素个数。除此之外，只有通过[ ]语法菜鞥你取用array对象。Arr...
【Java】 容器与数组的输出方式
haoweixl的博客
03-23 369
【Java】 容器与数组的输出方式一、容器输出方式二、数组的输出方式三、toString() 函数理解（二维数组） 一、容器输出方式 1、容器不同于数组，容器若是想输出全部元素，可以直接利用 System.out.println(collection)。此时默认调用了 toString() 方法。 输出的三种方法： 1、toString 2、foreach 3、Iterator package Packger; import java.util.HashSet; import java.util.It
Java容器中的元素输出
03-25 283
1、容器不同于数组，容器若是想输出全部元素，可以直接利用System.out.println(collection) public class TestCollectionArrayPrint { public static void main(String[] args){ Collection<String> collection = n...
Java--collection.rar_SEP_java 集合
09-21
Java集合框架是Java编程语言中的一个核心组件，它为数据存储和管理提供了强大的支持。这个框架包括了多种接口和类，使得程序员可以高效地处理对象集合。在"Java--collection.rar"这个压缩包中，我们可以找到名为...
java基础教程----精华版
09-22
- **变量**：在Java中，变量是存储数据的容器，分为基本类型（如int, double, boolean等）和引用类型（如类、接口、数组）。 - **数据类型**：Java有两大类数据类型，即原始类型（primitives）和引用类型...
Java源码分析：集合-容器.pdf
04-02
Java源码分析：集合-容器.pdf
Java集合容器面试题（2023最新版）-重点
最新发布
02-09
Java集合容器面试题（2023最新版）-重点 **集合框架：**用于存储数据的容器。 集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。 任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合...
C++对于容器的输出函数
m0_55895641的博客
11-19 1375
在C++的编程过程中，使用模板进行泛型编程是非常有必要的，本文为输出不同容器的输出函数，话不多说，上代码： #include<windows.h> #include<iostream> #include<vector> using namespace std; template<typename container> void printany_container(const container &c,ostream &out=cout)
Java 容器类型的打印
坚持学习
12-20 1023
在Java里打印容器里的内容无序任何帮助  使用容器类型的toString()方法即可。 import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Li
java 容器 set_Java编程用Set容器
weixin_28848933的博客
02-15 218
展开全部importjava.util.ArrayList;importjava.util.Collection;importjava.util.Collections;importjava.util.Comparator;importjava.util.HashSet;importjava.util.Set;/***有10本图书，2个属性：名称和ISBN号，将10本图书存放到一个S...
java 自定义一个容器类
weixin_30270561的博客
06-21 170
public class ArrayList { public int index = 0; Object[] objects = new Object[2]; public void add(Object o) { //当index超出最初定义数组的长度时，自动扩容 if(index == objects.length){...
【Java-35】数组、容器的输出
我的笔记
01-19 174
见代码 // 数组的输出 System.out.println(Arrays.toString(date)); // List容器的输出 System.out.println(list);  
Java中的容器Set集合
QuedYin的博客
07-01 332
Set集合继承了Conllection,是一种容器,里面装的数据不能重复。Set接口有三个实现类HashSet：主要使用，顺序跟添加顺序无关LinkedHashSet: 如果要求Set的顺序和添加顺序一致，建议使用。TreeSet：自定义排序规则；HashSetHashSet类按照哈希算法来存取集合中的对象，存取速度比较快。注意：set里面的数据不能重复set中的数据可以为空set中的数据是无续的...
关于容器输出的学习与简化过程
webcenterol
04-23 124
在学习C++标准库的过程中，各种容器是很大一块，每次验证自己的结果输出容器的时候除了string 可以简单的cout&lt;&lt;输出以外，其他的都要for()循环用迭代器遍历，比如输出vector&lt;int&gt; vec容器就要这样 for(vector&lt;int&gt;::iterator it = vec.begin(); it != vec.end(),++it) cou...
持有对象（2）：容器的打印、List
游王子的博客
02-17 292
一、容器的打印 你必须使用Arrays.toString()来产生数组的打印表示，但是打印容器无需任何帮助。下面是一个例子，这个例子中也介绍了一些基本类型的容器： import java.util.*; public class PrintingContainers { static Collection fill(Collection<String> collect...
Java容器类list使用记录
weixin_41570207的博客
11-02 106
刚写了一个错误代码，记录一下 1.新建一个容器类， 里面是什么都没有的，如果我们要输出容器类中第1个数据，会报错 List<String> list = new ArrayList<>(); System.out.println(list.get(0)); 下标超出边界了，也就是没有下标为0的数据。 2.当我们往这个容器中加入一个数据 List<String> list = new ArrayList<>(); list.add("123"); Syste
Java源码解析：集合与容器详解 - TreeSet与HashSet
Java源码分析：集合-容器.pdf深入探讨了Java中的集合框架，特别是单列集合Set和SortedSet中的具体实现。其中，TreeSet是一个特殊的SortedSet，它基于二叉树结构，对添加的新元素进行排序。对于使用TreeSet，关键在于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值