List
一个有序的集合，有序是指输入时的顺序与存储的顺序是一致的
//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
lastIndexOf(Object o) //查找指定元素最后一次出现的索引值，如果不包含指定索引值的元素，则返回-1
subList(int fromIndex,int toIndex) //指定开始与结束的索引值截取集合中的元素，包头不包尾
//迭代：(list中特有的迭代器)
listIterator() //返回一个列表迭代器在这个列表的元素(在适当的序列)
//listIterator特有的方法（都是操作索引值的）
用于比较，易于理解（next(): //先获取当前的游标指向的元素，然后游标向下移动一个单位）
hasPrevious（）： // 问是否有上一个元素
pervious（）： //游标先向上移动一个单位，然后获取当前游标指向的元素
add(): //把元素添加到当前游标指向的位置上
set(): //使用指定的元素替代迭代器最后一次返回的元素
四种遍历输出的方式
public class Iterative {
public static void main(String[] args) {
List list= new ArrayList();
list.add("王林");
list.add("万林");
list.add("表哥");
list.add("标哥");
// 方式一：toArray();
Object[] arr = list.toArray(); // 把集合的元素添加到一个Object数组中返回。
System.out.println("==========toArray方式遍历=========");
for(int i = 0; i < arr.length ; i++){
System.out.print(arr[i]+",");
}
// 方式二： 使用for循环配合 get的方式。
System.out.println("\r\n=====get方式遍历=====");
for(int i = 0 ; i< list.size() ; i++ ){
System.out.print(list.get(i)+",");
}
//方式三：使用迭代器正序遍历
System.out.println("\r\n======迭代器正序遍历========");
ListIterator it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next()+",");
}
//方式四：使用迭代器逆序遍历。
System.out.println("\r\n======迭代器逆序遍历========");
while(it.hasPrevious()){
System.out.print(it.previous()+",");
}
}
}
ArrayList
实现了所有可选列表操作,允许所有元素,包括 null。除了实现 List接口,这个类提供了方法来操作数组的大小,内部使用存储列表
- 特点
查询速度快，增删慢
快-->集合的特点，内存地址，是连续的，只要知道第一个数的内存地址，后面的只需要加下标即可
慢-->相应改变之后，从该索引值后的所有数值，都需要进行copy，所以比较慢
LinkedList（链表数据结构）
底层是使用了链表数据结构实现的
- 特点
查询速度慢，增删快
慢--->是因为，挨个查询，进行比较
快-->只是修改前一个记录内存的地址发生改变
- 常用的方法
1.方法介绍
addFirst(E e) //把元素添加到集合的首位值
addLast(E e) //把元素添加到集合的末尾位置
getFirst(E e) //获取集合的首元素
getLast(E e) //获取集合的末尾元素
removeFirst(E e) //移除集合中的首元素
removeLast(E e) //移除集合中的末尾元素
2.数据结构
1).栈（1.6）
先进后出
push()
pop()
2).队列（双端队列1.5）
先进先出
offer()
poll()
3.返回逆序的迭代对象
descendingIterator() //返回逆序的迭代对象
Set
没有特有的方法，全部继承与collection
- HashSet
- 具备集合的属性,底层使用哈希码表的支持，特点：存取快
- 存储原理
往HashSet添加元素的时候，首先会调用元素的HashCode(默认情况下获得的是内存地址[String 类已经对Object的HashCode方法进行重写])方法得到元素的哈希码值，通过元素的哈希码值就可以算出该元素在哈希表中的存储位置
- TreeSet
具备自然顺序的特点的元素，使用TreeSet可以自动进行排序
练习
练习1： 定义一个LinedList存储一批人对象，然后根据人的年龄进行存储。
package cn.itcast.test;
import java.util.LinkedList;
/*
练习1： 定义一个LinedList存储一批人对象，然后根据人的年龄进行存储。
*/
class Person{
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "{ 姓名："+this.name+" 年龄："+ this.age+"}" ;
}
}
public class Demo1 {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add(new Person("张三",19));
list.add(new Person("李四",9));
list.add(new Person("王五",15));
list.add(new Person("赵六",8));
sort(list);
System.out.println("集合的元素：" + list);
}
public static void sort(LinkedList list){
for(int i = 0 ; i< list.size()-1 ; i++){
for(int j = i+1 ; jp2.age){
list.set(i, p2);
list.set(j, p1);
}
}
}
}
}
练习2： 定义一个LinkedList存储一副扑克牌，再定义一个方法可以洗牌的。
package cn.itcast.test;
import java.util.LinkedList;
import java.util.Random;
/*
练习2： 定义一个LinkedList存储一副扑克牌，再定义一个方法可以洗牌的。
*/
//扑克
class Poker{
String color; //花色
String num; //点数
public Poker(String color, String num) {
super();
this.color = color;
this.num = num;
}
// alt+ / 内部补全
@Override
public String toString() {
return color+num;
}
}
public class Demo2 {
public static void main(String[] args) {
LinkedList pokers = createPoker();
shufflePoker(pokers);
showPoker(pokers);
}
//洗牌
public static void shufflePoker(LinkedList pokers){
Random random = new Random();
for(int i = 0 ; i<100 ; 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(index1, p2);
pokers.set(index2, p1);
}
}
//显示扑克牌
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 list = new LinkedList();
//定义一个数组存储所有的点数
String[] nums = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
//定义一个数组存储所有的花色
String[] colors = {"方块","梅花","红桃","黑桃"};
for(int i = 0 ; i< nums.length ; i++){
for(int j = 0 ; j< colors.length ; j++){
list.add(new Poker(colors[j], nums[i]));
}
}
return list;
}
}
练习3：使用Hashset实现注册功能， 注册的时候如果用户名与密码一致，则视为同一个用户，不允许注册。
package cn.itcast.test;
import java.util.HashSet;
import java.util.Scanner;
/*
练习3：使用Hashset实现注册功能， 注册的时候如果用户名与密码一致，则视为同一个用户，不允许注册。
*/
class User{
String userName;
String password;
public User(String userName, String password) {
this.userName = userName;
this.password = password;
}
@Override
public String toString() {
return "{ 用户名："+ this.userName+" 密码："+ this.password+"}";
}
@Override
public boolean equals(Object obj) {
User u = (User)obj;
return this.userName.equals(u.userName)&& this.password.equals(u.password);
}
// 狗娃 123 123 狗娃
@Override
public int hashCode() {
return this.userName.hashCode()+ this.password.hashCode();
}
}
public class Demo4 {
public static void main(String[] args) {
//定义一个集合用于存储用户
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("用户名与密码以存在，请重新注册!!");
}
System.out.println("当前的用户："+ users);
}
}
}