java日常学习：集合（二）list和set接口

java代码块

list接口

集合的体系：

———| Collection 单列集合的根接口。

————-| List 如果是实现了List接口的集合类，具备的特点： 有序，元素可重复。

————-| Set 如果是实现了Set接口的集合类，具备的特点： 无序，元素不可重复。

有序：在集合中所谓的“有序”不是指自然顺序，而是指添加进去的顺序与存储的顺序一致。

List接口下面特有的方法：

增加
add(int index, E element)     指定索引值添加元素

addAll(int index, Collection c)  指定索引值把一个集合的元素添加到另外一个集合中、

删除
remove(int index)   指定索引值删除元素

修改

set(int index, E element)      指定索引值修改元素

获取
get(int index)       根据索引值获取元素

indexOf(Object o)    查找指定元素第一次出现的索引值, 如果不包含指定的元素则返回-1表示.

subList(int fromIndex, int toIndex)   指定开始于结束的索引值截取集合中的元素，返回迭代

listIterator()

List接口特有的方法都是操作索引值的

获取

get(int index) 根据索引值获取元素

indexOf(Object o) 查找指定元素第一次出现的索引值, 如果不包含指定的元素则返回-1表示.

lastIndexOf(Object o) 查找指定元素最后一次出现的索引值， 如果不包含指定的元素则返回-1表示.

subList(int fromIndex, int toIndex) 指定开始于结束的索引值截取集合中的元素，返回

迭代

listIterator()

迭代

listIterator()

listIterator特有的方法：

next()  :    先获取当前游标指向的元素，然后游标向下移动一个 单位。

hasPrevious()  问是否有上一个元素
previous()     游标先向上移动一个单位，然后获取当前游标指向的元素。

add(E e)        把元素添加到当前游标指向的位置上。
set(E e)        使用指定的元素替代迭代器最后一次返回的元素。

迭代器在迭代的过程中要注意的事项：

1. 迭代器在迭代的过程中不准使用集合对象改变集合的元素个数。 否则会报出：ConcurrentModificationException

2. 在迭代过程中如果需要改变集合中的元素个数，只能使用迭代器的方法去改变。

ArrayList的应用场景：

如果操作的数据时查询比较多，增删比较少，这时候则应该使用ArrayList. 比如： 图书馆。

——————| LinkedList

——————| Vector (了解)

————–| Set 如果是实现了Set接口的集合类具备的特点： 无序，元素不可重复。

笔试题目：使用 ArrayList无参的构造方法是默认的容量是多少？ 当容量不够使用时，自动回增长多少？

ArrayList的底层是使用了一个Object数组去实现的，往ArrayList存储数据的时候，数据实际上

是存储到了Object数组中， 使用无参构造函数是，Object数组的初始化容量是10， 当容量不够使用时会自动自增原来的0.5倍。

LinkedList特有的方法：

1：方法介绍
addFirst(E e)   把元素添加到集合的首位置
addLast(E e)    把元素添加到集合的末尾处。

getFirst()     获取集合的首位置元素
getLast()        获取集合的末尾元素

removeFirst()   删除集合的首元素
removeLast()    删除集合的末尾元素

2：数据结构
1：栈 （1.6）
先进后出
push()
pop()

2：队列（双端队列1.5）
先进先出
offer()
poll()
3：返回逆序的迭代器对象
descendingIterator()   返回逆序的迭代器对象

set接口

集合的体系：

———| Collection 单列集合的根接口

————–| List 如果是实现了List接口的集合类具备的特点： 有序，元素可重复。

——————| ArrayList ArrayList的底层是维护了一个Object数组去实现的， 特点： 查询速度快，增删慢。

——————| LinkedList 底层是使用了链表数据结构实现的， 特点： 查询速度慢， 增删快。

——————| Vector (了解) Vector 的底层也是使用一个Object数组去实现 的， 但是Vector线程安全的，操作效率低。

————–| Set 如果是实现了Set接口的集合类具备的特点： 无序，元素不可重复。

——————| HashSet
b677
底层是使用了哈希表支持的， 特点： 存取的速度快。 假设

——————| TreeSet

hashSet存储原理：

往hashSet添加元素的时候，首先会调用元素的hashCode方法得到元素的哈希码值，通过哈希码值就可以算出

该元素在哈希表中的存储位置 。

情况1： 如果根据元素的哈希码算出的位置目前没有任何元素存储在该位置上，那么该元素可以直接添加到哈希表中。

情况2： 如果根据元素的哈希码算出的位置目前已经有其他元素存储在了该位置上，那么还会调用元素的equals方法再与这个位置上的元素

再比较一次，如果equals方法返回的是true，则视为重复元素，不允许添加到哈希表中，如果equals方法返回的是false，该元素则允许添加到

哈希表中。

练习一

//需求： 定义一个函数清除集合中的重复元素。 只要书号一致则为同一本书。
package day05_test;

import java.util.ArrayList;
import java.util.Iterator;

class Book {
int id;
String name;
double price;

public Book(int id, String name, double price) {
this.id = id;
this.name = name;
this.price = price;
}

@Override
public String toString() {
// TODO Auto-generated method stub
return "{ 书号：" + this.id + " 书名：" + this.name + " }";
}

public boolean equals(Object obj) {
Book book = (Book) obj;
return this.id == book.id;
}

@Override
public int hashCode() {
// TODO Auto-generated method stub
return this.id;
}
}

public class Demo1 {

public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list = new ArrayList();
list.add(new Book(110, "java", 88));
list.add(new Book(120, "c", 66));
list.add(new Book(110, "JAVA", 99));
list.add(new Book(140, "汇编", 111));

ArrayList newList = clearRepeat(list);
System.out.println("老书籍是：" + list);
System.out.println("新书籍是：" + newList);
}

public static ArrayList clearRepeat(ArrayList OldList) {
ArrayList newList = new ArrayList();

Iterator iterator = OldList.iterator(); // 获取迭代器对象
while (iterator.hasNext()) {
Book book = (Book) iterator.next(); // 从旧集合中取出的元素 , 判断新集合中是否存在该元素
if (!newList.contains(book)) { // contains 底层是依赖euqals方法，equals默认比较的是内存地址。
// 如果不包含该本书籍，则应该添加到新集合中
newList.add(book);
}
}
return newList;
}

}

练习二

package day05_test;

//定义一个LinedList存储一批人对象，然后根据人的年龄进行存储。
import java.awt.List;
import java.util.LinkedList;

import javax.naming.ldap.SortControl;

class Person {
int age;
String name;

public Person(int age, String name) {
this.age = age;
this.name = name;
}

@Override
public String toString() {
// TODO Auto-generated method stub
return "{ 姓名：" + this.name + " 年龄：" + this.age + "}";
}

}

public class Demo2 {

public static void main(String[] args) {
// TODO Auto-generated method stub
LinkedList linkedList = new LinkedList();
linkedList.add(new Person(20, "张三"));
linkedList.add(new Person(19, "李四"));
linkedList.add(new Person(23, "王五"));
linkedList.add(new Person(21, "李六"));
linkedList.add(new Person(25, "赵七"));

System.out.println(linkedList);
sort(linkedList);
System.out.println(linkedList);

}

public static void sort(LinkedList linkedList) {
for (int i = 0; i < linkedList.size() - 1; i++) {
for (int j = i + 1; j < linkedList.size(); j++) {
Person p1 = (Person) linkedList.get(i);
Person p2 = (Person) linkedList.get(j);

if (p1.age > p2.age) {
linkedList.set(i, p2);
linkedList.set(j, p1);
}
}
}
}

}

练习三

package day05_test;

//定义一个LinkedList存储一副扑克牌，再定义一个方法可以洗牌的。
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Random;

import org.omg.PortableInterceptor.IORInterceptor;

class Poker {
String color; // 花色
String num; // 花色

public Poker(String color, String num) {
this.color = color;
this.num = num;
}

@Override
public String toString() {
// TODO Auto-generated method stub
return color + num;
}
}

public class Demo3 {

public static void main(String[] args) {
// TODO Auto-generated method stub
LinkedList pokers = createPoker();
shufflePoker(pokers);
showPoker(pokers);
}

// 洗牌
public static void shufflePoker(LinkedList pokers) {

Random random = new Random();

for (int i = 0; i < 500; i++) {
// 随即产生两个索引值
int index1 = random.nextInt(pokers.size());
int index2 = random.nextInt(pokers.size());
// 让两张牌的位置交换
Poker p1 = (Poker) pokers.get(index1);
Poker p2 = (Poker) pokers.get(index2);

pokers.set(index2, p1);
pokers.set(index1, p2);
}
}

// 显示扑克牌

public static void showPoker(LinkedList pokers) {
for (int i = 0; i < pokers.size(); i++) {
if (i % 10 == 9) {
System.out.println(pokers.get(i));
} else {
System.out.print(pokers.get(i) + ",");
}
}
}

// 生成一副扑克牌
public static LinkedList createPoker() {
// 定义一个集合存储扑克牌
LinkedList linkedList = new LinkedList();
// 定义一个数组存储所有的点数
String[] num = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };
// 定义一个数组存储所有的花色
String[] colors = { "方块", "梅花", "红桃", "黑桃" };

for (int i = 0; i < num.length; i++) {
for (int j = 0; j < colors.length; j++) {
linkedList.add(new Poker(colors[j], num[i]));
}

}
return linkedList;
}

}

练习四

package day05_test;
//使用Hashset实现注册功能， 注册的时候如果用户名与密码一致，则视为同一个用户，不允许注册。

import java.util.HashSet;
import java.util.Scanner;

class User {
String userName;
String passWord;

public User(String userName, String passWord) {
this.userName = userName;
this.passWord = passWord;
}

@Override
public String toString() {
// TODO Auto-generated method stub
return "{ 用户名：" + this.userName + " 密码：" + this.passWord + "}";
}

@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
User u = (User) obj;
return this.userName.equals(u.userName) && this.passWord.equals(u.passWord);
}

@Override

public int hashCode() {
// TODO Auto-generated method stub
return this.userName.hashCode() + this.passWord.hashCode();
}
}

public class Demo4 {

public static void main(String[] args) {
// TODO Auto-generated method stub
// 定义一个集合用于存储用户
HashSet users = new HashSet();
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("请输入用户名：");
String userName = scanner.next();
System.out.println("请输入密码：");
String passWord = scanner.next();
User user = new User(userName, passWord);
if (users.add(user)) {
System.out.println("添加用户成功");
} else {
System.out.println("添加用户失败,用户名与密码已经存在");
}
}

}

}

用于平时自己复习回顾，如有错误，欢迎指正

个人微信号：yxx85561498，欢迎一起学习交流，努力进步