Collection单列集合复习

最新推荐文章于 2023-09-16 08:22:31 发布

「已注销」

最新推荐文章于 2023-09-16 08:22:31 发布

阅读量209

点赞数

分类专栏：第一阶段文章标签： Collection List Set

本文链接：https://blog.csdn.net/qq_40245464/article/details/103103734

版权

第一阶段专栏收录该内容

23 篇文章 0 订阅

订阅专栏

集合

(Map中还有LinkedHashMap和TreeMap(二叉树存储))

Collection集合的遍历

1.集合转换成数组，然后再对数组进行遍历

Object[]

toArray()

返回一个包含此集合中所有元素的数组。

Object[] toArray();

2.获取迭代器、当于一个爪子

Iterator<E>

iterator()

返回此集合中的元素的迭代器。

boolean

hasNext()

如果迭代具有更多元素，则返回 true 。

next()

返回迭代中的下一个元素。

hesNext:判断是否有下一个元素

next:获取下一个元素,还会移动迭代器的位置

3.高级for循环(底层实现就是迭代器)

Collection集合三种通用遍历方式实例:

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class Test02 {

public static void main(String[] args) {

Collection<Student> coll = new ArrayList<Student>();

//Collection是接口,不能创建对象,所以只能创建子类对象(多态)

Student s1 = new Student("熊落落",21);

Student s2 = new Student("杨梦梦",22);

Student s3 = new Student("李鹏鹏",25);

Student s4 = new Student("崔美娟",23);

Student s5 = new Student("孙二娜",22);

Student s6 = new Student("红果果",21);

coll.add(s1);coll.add(s2);

coll.add(s3);coll.add(s4);

coll.add(s5);coll.add(s6);

System.out.println("******第一种遍历方式******");

//单列集合通用的第一种遍历方式(调用toArray()方法,转为数组,然后遍历)

Object[] objs = coll.toArray();//注意单列集合的这个toArray()方法返回值是一个Object类型的数组

for(Object obj : objs) {

/*String string = obj.toString();

System.out.println(string);

多态(父类的引用指向子类的对象)中的成员方法的访问特点

1.编译看左边，运行看右边

2.编译的时候，要看父类中是否存在该方法，如果存在，编译通过，否则编译报错。

3.运行的时候，要运行子类的重写的方法，如果没有重写的方法，执行父类的方法。*/

Student stu = (Student)obj;

/*不强转为子类对象的引用stu时,obj只能调用两者共有的方法中的子类对象的方法而不能调用Student类中特有的方法.

这其实是多态的访问特点,好好学习吧!学完就忘,像个憨憨,丢人不*/

System.out.println(stu);

}

System.out.println("******第一种遍历方式******");

System.out.println();

System.out.println("******第二种遍历方式******");

//单列集合通用的第二种遍历方式(采用Iterator迭代器进行遍历)

Iterator<Student> it = coll.iterator();//使用泛型,声明迭代器类型

//Iterator迭代器是个接口,不能直接创建对象,但可以通过集合调用iterator()方法创建对象

while(it.hasNext()) {//如果集合中还有元素

System.out.println(it.next());//获取集合中下一个元素

}

System.out.println("******第二种遍历方式******");

System.out.println();

System.out.println("******第三种遍历方式******");

//单列集合通过的第三种遍历方式(采用高级for循环进行遍历)

for(Student stu : coll) {//由于前面声明了泛型,这里遍历就省去了很多麻烦

System.out.println(stu);

}

System.out.println("******第三种遍历方式******");

}

class Student{

private String name;

private int age;

public Student() {}

public Student(String name,int age) {

this.name = name;

this.age = age;

}

public void setName(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void setAge(int age) {

this.age = age;

}

public int getAge() {

return age;

}

public String toString() {//由于在打印对象名的时候,虚拟机会自动调用toString方法,打印对象地址

//所以可以重写toString()方法,打印出我们希望看到的结果!注意:这个方法的返回类型是String类型!

//调用是虚拟机自动完成的!

return "name = " + name + ",age = " + age;

}

List集合中特有的遍历方式实例:

(使用size(),get()等方法进行遍历

import java.util.ArrayList;

import java.util.List;

//List集合中特有的遍历(使用size(),get()等方法进行遍历)

public class Test03 {

public static void main(String[] args) {

/*List list = new ArrayList();

list.add(0, 3);

list.add(0, 4);

System.out.println(list);

list.remove(0);

System.out.println(list);

list.set(0, 6);

System.out.println(list);

System.out.println(list.get(0));*/

List list = new ArrayList();

list.add("我和我的祖国");

list.add("一刻也不能分割");

list.add("只愿天长地久");

list.add("与我意中人儿紧相随");

list.add(123);

list.add(456);

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

System.out.println(list.get(n));

}

并发修改异常

java.util.ConcurrentModificationException

原因：在使用迭代器操作集合时，集合本身也在操作集合，所以出现并发修改的异常。

解决方式：要么集合本身在操作集合，要么迭代器在操作集合。

Vector:

public class Test04 {

public static void main(String[] args) {

Vector vector = new Vector();

vector.addElement("abc");

vector.addElement("bbb");

vector.addElement("ccc");

vector.addElement("ddd");

System.out.println(vector);

System.out.println(vector.removeElement("abc"));

System.out.println(vector);

//遍历枚举器

Enumeration elements = vector.elements();

while(elements.hasMoreElements()) {

System.out.println(elements.nextElement());

}

枚举器中的两个方法

boolean

hasMoreElements()

测试此枚举是否包含更多元素。

nextElement()

如果此枚举对象至少有一个要提供的元素，则返回此枚举的下一个元素。

LinkedList练习一:

import java.util.LinkedList;

public class LinkedList01 {

public static void main(String[] args) {

LinkedList ll = new LinkedList();

ll.addFirst("abc");

ll.addFirst("aaa");

ll.addLast("ccc");

System.out.println(ll);

//[aaa, abc, ccc]

Object obj = ll.removeLast();

System.out.println(obj);

//ccc

System.out.println(ll);

//[aaa, abc]

System.out.println(ll.getFirst());

//aaa

}

LinkedList练习二:

模拟栈和队列的操作

import java.util.LinkedList;

/*4.模拟栈和队列的操作(LinkedList)

栈：先进后出自定义异常抛出

队列：先进先出*/

public class Test02LinkedList {

public static void main(String[] args) throws Exception {

MyStack<String> ms = new MyStack<String>();

ms.push("123");

ms.push("我爱你,祖国!");

ms.push("wakaka");

System.out.println(ms);

System.out.println(ms.pop());

}

class MyStack<E>{//栈本身就是一种操作受限的链表

LinkedList<E> linkedList = new LinkedList<E>();

public MyStack() {}

public void push(E e) {

linkedList.addLast(e);//进栈,加元素

}

public E pop() throws Exception {

if(isEmpty()) {

throw new MyStackEmptyException("感觉身体被掏空!");

}

return linkedList.removeLast();//这里出栈应该用移除来代替

}

public boolean isEmpty() {

return linkedList.isEmpty();

}

class MyStackEmptyException extends Exception{

public MyStackEmptyException(String str) {

super(str);

}

Set:元素无序,不重复

练习一:

随机生成10个20-40之间的(不重复的)随机数，存储在合适的集合中，并且进行遍历

/*6.练习

随机生成10个20-40之间的(不重复的)随机数，存储在合适的集合中，并且进行遍历*/

public class Test01Set {

public static void main(String[] args) {

Random r = new Random();

Set<Integer> set = new HashSet<Integer>();

while(set.size()<10) {

int num = r.nextInt(21)+20;

set.add(num);

}

for(Integer n : set) {

System.out.println(n);

}

练习二:

键盘录入一个字符串，输出其中的字符，相同的字符只输出一次。

import java.util.HashSet;

import java.util.Scanner;

import java.util.Set;

/*2.键盘录入一个字符串，输出其中的字符，相同的字符只输出一次。*/

public class Test02Set {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请录入一个字符串:");

String line = sc.nextLine();

char[] chs = line.toCharArray();

Set<Character> set = new HashSet<Character>();

for(int n = 0;n < chs.length;n++) {

char c = chs[n];

set.add(c);

}

for(Character c : set) {

System.out.println(c);

}

HashSet

哈希表，HashSet保证了元素的唯一性，值相同的元素都去掉。

HashSet存储自定义类型的元素

如何保证元素唯一呢?

hashCode()

|--哈希值相同：再进去比较equals()

|--equals值返回为true:认为是重复元素，不进行存储

|--equals值返回为false:认为不是重复元素，进行存储

|--哈希值不相同：直接进行存储

HashSet保证自定元素唯一性的实例:

import java.util.HashSet;

import java.util.Iterator;

import java.util.Objects;

//测试HashSet如何保证自定义元素唯一

public class Test01HashSet {

public static void main(String[] args) {

HashSet hs = new HashSet();

hs.add(new Student("熊落落",21));

hs.add(new Student("杨梦梦",22));

hs.add(new Student("李鹏鹏",25));

hs.add(new Student("孙二娜",24));

hs.add(new Student("熊落落",23));

hs.add(new Student("熊落落",21));

Iterator it = hs.iterator();

while(it.hasNext()) {

Student stu = (Student)it.next();

System.out.println(stu);

}

/*输出结果:

29015722

26296872

26711470

23119401

29015722

name = 熊落落,age = 21

name = 熊落落,age = 23

name = 杨梦梦,age = 22

name = 李鹏鹏,age = 25

name = 孙二娜,age = 24

根据定义的规则,线比较对象name的哈希码值,如果不一致,直接存储,

如果一致,再去比较姓名和年龄的值是否一样,不一致,存储.一致,不存储.

}

class Student{

private String name;

private int age;

public Student() {}

public Student(String name,int age) {

this.name = name;

this.age = age;

}

public void setName(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void setAge(int age) {

this.age = age;

}

public int getAge() {

return age;

}

public String toString() {//由于在打印对象名的时候,虚拟机会自动调用toString方法,打印对象地址

//所以可以重写toString()方法,打印出我们希望看到的结果!注意:这个方法的返回类型是String类型!

//调用是虚拟机自动完成的!

return "name = " + name + ",age = " + age;

}

public int hashCode() {

/*Objects.hash()与Objects.hashCode()

* static int hash(Object... values)

为(多个)输入值序列生成哈希码,最好不要输入单个(返回的可能不是哈希码值);

static int hashCode(Object o)

返回单个输入值的哈希码值 */

/*System.out.println(Objects.hashCode(age));

return Objects.hashCode(age);*///如果年龄的哈希值一样(int类型的哈希码值就是它本身,没什么意义

System.out.println(Objects.hashCode(name));

return name.hashCode();//字符串是引用数据类型,可直接调用hashCode()方法

}

public boolean equals(Object obj) {//注意,它的返回值是boolean类型

Student stu = (Student)obj;

return name.equals(stu.name)&&age==stu.age;//认真,别写错了

//比较姓名和年龄是否一样

}

TreeSet:

也是一个Set子类，也可以保证元素的唯一，底层结构是二叉树。

既可以保证元素唯一，也可能进行自动排序

TreeSet可以保证元素唯一，也可以自动排序。

|--使元素本身具有比较性，自定义类实现Comparable接口，重写comparTo()方法

|--使集合本身具有比较性，自定义比较器实现Comparator接口，重写compare()方法

如果两者同时存在呢？？？

使用集合本身的比较性，元素本身的比较效失效！！

TreeSet集合保证自定义元素唯一的两种方式

TreeSet集合保证自定义对象唯一的实例一():

自定义类实现一个Comparable接口，重写compareTo()

返回值：正整数、零、负整数

题目:如果本书的书名和价格一致认为同一本书，不进行存储

按照书名进行升序排序，如果书名相同，按照价格降序排序(用TreeSet存储)

import java.util.Iterator;

import java.util.TreeSet;

/*题目:如果本书的书名和价格一致认为同一本书，不进行存储

按照书名进行升序排序，如果书名相同，按照价格降序排序(用TreeSet存储)*/

public class Test01TreeSet {

public static void main(String[] args) {

TreeSet ts = new TreeSet();

Book b1 = new Book("活着",25);

Book b2 = new Book("果宝",21);

Book b3 = new Book("王者",22);

Book b4 = new Book("活着",23);

Book b5 = new Book("活着",25);

ts.add(b1);ts.add(b2);

ts.add(b3);ts.add(b4);

ts.add(b5);

Iterator it = ts.iterator();

while(it.hasNext()) {

Book b = (Book)it.next();

System.out.println(b);

}

class Book implements Comparable{

String bookName;

double bookPrice;

public Book() {

super();

// TODO Auto-generated constructor stub

}

public Book(String bookName, double bookPrice) {

super();

this.bookName = bookName;

this.bookPrice = bookPrice;

}

public String getBookName() {

return bookName;

}

public void setBookName(String bookName) {

this.bookName = bookName;

}

public double getBookPrice() {

return bookPrice;

}

public void setBookPrice(double bookPrice) {

this.bookPrice = bookPrice;

}

@Override

public String toString() {

return "Book [bookName=" + bookName + ", bookPrice=" + bookPrice + "]";

}

/*题目:如果本书的书名和价格一致认为同一本书，不进行存储

按照书名进行升序排序，如果书名相同，按照价格降序排序(用TreeSet存储)*/

public int compareTo(Object obj) {

Book b = (Book)obj;

int result = bookName.compareTo(b.getBookName());

if(result==0) {//如果书名一致,判断价格

return -(new Double(bookPrice).compareTo(new Double(b.getBookPrice())));

//降序 Double也继承了Compareble类,重写了compareTo方法,所以可以这么写

}else if(result > 0) {

return 1;//名字升序

}

return -1;

}

运行结果:

Book [bookName=果宝, bookPrice=21.0]

Book [bookName=活着, bookPrice=25.0]

Book [bookName=活着, bookPrice=23.0]

Book [bookName=王者, bookPrice=22.0]

TreeSet集合保证自定义对象唯一的实例二():

TreeSet集合本身具有比较性，在创建集合对象时添加一个比较器，自定义比较器实现Comparator,重写compare方法，使添加的元素按照集合本身的比较规则去进行添加

题目:如果本书的书名和价格一致认为同一本书，不进行存储

按照书名进行降序排序，如果书名相同，按照价格升序排序(用TreeSet存储)

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

/*题目:如果本书的书名和价格一致认为同一本书，不进行存储

按照书名进行降序排序，如果书名相同，按照价格升排序(用TreeSet存储)*/

public class Test02TreeSet {

public static void main(String[] args) {

TreeSet ts = new TreeSet(new Comparator() {

public int compare(Object o1,Object o2) {

Book b1 = (Book)o1;

Book b2 = (Book)o2;

int result = b1.getBookName().compareTo(b2.getBookName());

if(result==0) {

return new Double(b1.getBookPrice()).compareTo(new Double(b2.getBookPrice()));

}else if(result > 0) {

return -1;

}

return 1;

}

});

Book b1 = new Book("活着",25);

Book b2 = new Book("果宝",21);

Book b3 = new Book("王者",22);

Book b4 = new Book("活着",23);

Book b5 = new Book("活着",25);

ts.add(b1);ts.add(b2);

ts.add(b3);ts.add(b4);

ts.add(b5);

Iterator it = ts.iterator();

while(it.hasNext()) {

Book b = (Book)it.next();

System.out.println(b);

}

class Book implements Comparable{

String bookName;

double bookPrice;

public Book() {

super();

// TODO Auto-generated constructor stub

}

public Book(String bookName, double bookPrice) {

super();

this.bookName = bookName;

this.bookPrice = bookPrice;

}

public String getBookName() {

return bookName;

}

public void setBookName(String bookName) {

this.bookName = bookName;

}

public double getBookPrice() {

return bookPrice;

}

public void setBookPrice(double bookPrice) {

this.bookPrice = bookPrice;

}

@Override

public String toString() {

return "Book [bookName=" + bookName + ", bookPrice=" + bookPrice + "]";

}

/*题目:如果本书的书名和价格一致认为同一本书，不进行存储

按照书名进行升序排序，如果书名相同，按照价格降序排序(用TreeSet存储)*/

public int compareTo(Object obj) {

Book b = (Book)obj;

int result = bookName.compareTo(b.getBookName());

if(result==0) {//如果书名一致,判断价格

return -(new Double(bookPrice).compareTo(new Double(b.getBookPrice())));

//降序 Double也继承了Compareble类,重写了compareTo方法,所以可以这么写

}else if(result > 0) {

return 1;//名字升序

}

return -1;

}

运行结果:

Book [bookName=王者, bookPrice=22.0]

Book [bookName=活着, bookPrice=23.0]

Book [bookName=活着, bookPrice=25.0]

Book [bookName=果宝, bookPrice=21.0]

可见,当两者同时存在时,TreeSet会按照Comparator定义的规则去存储,排序

「已注销」

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Collection单列集合复习

集合(Map中还有LinkedHashMap和TreeMap(二叉树存储))Collection集合的遍历1.集合转换成数组，然后再对数组进行遍历 Object[] toArray() 返回一个包含此集合中所有元素的数组。 Object[] toArray();2.获取迭代器、当于一个爪子 Iterator&...
复制链接

扫一扫