集合类的特点:提供一种存储空间可变的存储类型,存储的数据容量可以随时发生改变
-
Collection
-
List
-
Set
-
泛型
-
Map
-
Collections
集合类有很多,such as ArrayList
//通过集合对象获取迭代器对象;Iterator是接口;iterator是继承接口的类的实现对象
package com.xm.study.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class A {
public static void main(String[] args) {
Collection collection=new ArrayList<>();
collection.add("你好吗");
collection.add("我很好");
System.out.println(collection.add("我也是"));
System.out.println(collection);
//通过集合对象获取迭代器对象;Iterator是接口;iterator是继承接口的类的实现对象
Iterator iterator = collection.iterator();
while(iterator.hasNext())
{
System.out.println(iterator.next());
}
for (String s : collection)
{
System.out.println(s);
}
collection.remove("你好吗");
System.out.println(collection.size());
}
}
List
list 集合中的方法 Array list中一定有,而Collection中不一定有:
set,get等等
package com.xm.study.list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class A {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add("你好吗");
list.add("我很好");
list.add("我也是");
list.add("我很好");
Iterator iterator = list.iterator();
ListIterator listIterator = list.listIterator();
System.out.println(list);
list.add(1, "world");
System.out.println(list.remove(1));
System.out.println(list.set(1, "是"));
System.out.println(list.get(1));
for (int i = 0; i < list.size(); i++) {
String str = list.get(i);
System.out.print(str + " ");
}
}
}
当我们在遍历实现了collection接口与iterator接口的集合时(List、Set、Map), 我们可以通过遍历索引也可以通过迭代器进行遍历。在我们使用迭代器进行遍历集合的时候,会获取到当前集合的迭代对象。在里面有封装了迭代器的remove方法与集合自带的remove方法,如果我们调用迭代器对象的remove方法是没问题的,但是当我们调用集合自带的remove方法时,就会产生Concurrent Modification Exception 并发修改异常。
Iterator
迭代器遍历过程中,通过集合对象修改了集合中的元素的长度,造成了迭代器获取元素中 判断预期修改值和现实修改值不一致
解决方案:用for循环遍历,然后用集合对象做对应的操作即可
package com.xm.study.list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class concurrentException {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add("你好吗");
list.add("我很好");
list.add("我也是");
Iterator iterator = list.iterator();
//list.add("what");
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
list.add("what");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
List Iterator迭代器
解决了并发问题
通过List 集合的list Iterator()方法得到,所以它是List集合特有的迭代器
package com.xm.study.list;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class listIterator {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add("你好吗");
list.add("我很好");
list.add("我也是");
ListIterator listIterator = list.listIterator();
listIterator.add("name");
while (listIterator.hasNext()) {
if (listIterator.next().equals("我很好")) {
listIterator.add("nb");
}
}
System.out.println(list);
}
}
增强for循环:内部原理是一个Iterator迭代器;
实现Iterable接口的类允许其对象成为for语句的目标
for(String element:list) {
if (element.equals("我很好")) {
list.add("nb");
}
}
所以出错 Concurrent Modification Exception
while (listIterator.hasNext()) {
if (listIterator.next().equals("我很好")) {
listIterator.add("nb");
}
}
正确;
数组:查询快,增删慢;
链表: 查询慢,增删快;
Array List 底层原理是数组;
Linked List 底层原理是双链表;
Linked Listpackage com.xm.study.list;
import java.util.LinkedList;
public class linkedList {
public static void main(String[] args) {
LinkedList linkedList=new LinkedList<>();
linkedList.add("肖猛");
System.out.println(linkedList);
linkedList.addFirst("李伟晴");
System.out.println(linkedList);
linkedList.addLast("东旭");
System.out.println(linkedList);
System.out.println(linkedList.lastIndexOf("东旭"));
System.out.println(linkedList.getFirst());
System.out.println(linkedList.getLast());
System.out.println(linkedList.removeFirst());
System.out.println(linkedList.removeLast());
System.out.println(linkedList.remove("东旭"));
System.out.println("---------");
System.out.println(linkedList.remove());
System.out.println(linkedList);
}
}
Set
Set接口继承Collection接口
HashSet底层的原理是哈希表;不能通过索引遍历,可以迭代器和增强型for循环
HashSet类的底层结构是哈希表;
LinkedHashSetLinkedHashSet类继承HashSet类:底层结构是哈希表和链表;
-
它维护了一个贯穿其所有条目的双向链表。 此链接列表定义迭代排序,即元素插入集合( 插入顺序 ) 的顺序 。
-
此实现使客户免于HashSet提供的未指定的,通常是混乱的排序,而不会导致与TreeSet相关的增加的成本。无论原始集合的实现如何,它都可用于生成与原始集合具有相同顺序的集合的副本:
TreeSet 间接使用Set接口,无索引,底层原理是红黑树
自然排序Comparable
-
此接口对实现它的每个类的对象强加一个总排序。 这种排序被称为类的自然排序 ,类的compareTo方法被称为其自然比较方法 。
-
按字典顺序比较两个字符串,忽略大小写差异。此方法返回一个整数,其符号是调用compareTo的整数,其中字符串的规范化版本通过在每个字符上调用Character.toLowerCase(Character.toUpperCase(character))消除了大小写差异。
-
请注意,此方法不场所考虑,并会导致特定的语言环境不满意的排序。 java.text包提供了collators以允许区分设置敏感的排序。
Student
package com.xm.study.set; public class Student implements Comparable{ String name; int age; public String getName() { return name; } public Student(String name, int age) { this.name = name; this.age = age; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int compareTo(Student s) { // if (this.age - s.age > 0) // return 1; // else if (this.age - s.age < 0) // return -1; // else { // return Character.compare(this.getName().charAt(0), s.getName().charAt(0)); // } int num=this.age-s.age; return num==0?this.name.compareTo(s.name):num; } }
Comparable
package com.xm.study.set;
import java.util.TreeSet;
//优先年龄从小到达,名字字母排序
public class TestComparable {
public static void main(String[] args) {
TreeSet ts=new TreeSet<>();
Student s1=new Student("b肖猛",12);
Student s2=new Student("a李伟晴",12);
Student s3=new Student("刘东旭",14);
Student s4=new Student("罗鑫洋",15);
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
for(Student student:ts)
{
System.out.println(student.getName()+student.getAge());
}
}
}
比较排序Comparator
Student
package com.xm.study.set;
public class Student {
String name;
int age;
public String getName() {
return name;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Comparator
package com.xm.study.set;
import java.util.Comparator;
import java.util.TreeSet;
public class TestComparator {
public static void main(String[] args) {
TreeSet ts = new TreeSet<>((o1, o2) -> {
int num = o1.getAge() - o2.getAge();
return num == 0 ? o1.getName().compareTo(o2.getName()) : num;
});
Student s1=new Student("b肖猛",12);
Student s2=new Student("a李伟晴",12);
Student s3=new Student("刘东旭",14);
Student s4=new Student("罗鑫洋",15);
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
for(Student student:ts)
{
System.out.println(student.getName()+student.getAge());
}
}
}
成绩比较类
package com.xm.study.set;
import java.util.TreeSet;
public class 成绩比较类 {
public static void main(String[] args) {
TreeSet ts=new TreeSet<>((s1,s2)->{
int num=(s2.getMath()+s2.getChinese())-(s1.getChinese()+s1.getMath());
int num1=num==0?s2.getChinese()-s1.getChinese():num;
int num2=num1==0?s2.getName().compareTo(s1.getName()):num1;
return num2;
});
Student2 s1=new Student2("肖猛",100,400);
Student2 s3=new Student2("李伟晴",150,50);
Student2 s2=new Student2("李振宇",150,50);
ts.add(s1);
ts.add(s2);
ts.add(s3);
for(Student2 s:ts)
{
System.out.println(s.getName());
}
}
}
产生随机数
Hash set不会排序
Tree set会排序
package com.xm.study.set;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
public class 随机数 {
public static void main(String[] args) {
Set set= new TreeSet<>();
Random r=new Random();
while(set.size()<10)
{
int num=r.nextInt(20)+1;
set.add(num);
}
for(Integer i:set)
{
System.out.println(i);
}
}
}
泛型
泛型定义
类型通配符
list>代表元素类型未知的List,他的元素可以匹配任意类型;
List extends> 类型通配符上限:List extends Number>他代表的类型是Number或Integer
List super>类型通配符下限:List super Number>他代表的是Number或Object
可变参数可变参数的定义
多个参数的情况下,可变参数要放在后边
具体实现:
package com.xm.study.泛型;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
public class 可变参数 {
public static void main(String... args) {
List list = Arrays.asList("你好", "我不好", "桥梁");
// list.add("瓦胡同");
// list.remove("你好");不能改变大小;
list.set(1, "nb ");
System.out.println(list);
List list2 = List.of("你好", "我不好", "桥梁");
// list.add("瓦胡同");
// list.remove("你好");不能改变大小和值;
// list.set(1, "nb ");
System.out.println(list2);
Set set=Set.of("你好", "我不好", "桥梁");
// set.add("瓦胡同");
// set.remove("你好");不能改变大小和值;
// set.set();Set接口没有索引所以没有set 方法
System.out.println(set);
}
}
Map
功能
package com.xm.study.Map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class 获取功能 {
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("肖猛", 12);
map.put("李伟晴", 15);
map.put("肖紫嫣", 6);
System.out.println(map.get("肖猛"));
Set set = map.keySet();//获取键
System.out.println(set);
for (String s : set)
System.out.println(s);
Collection collection = map.values();//获取值
System.out.println(collection);
for (Integer i : collection)
System.out.println(i);
//获取键和值
Set> entrySet = map.entrySet();
for(Map.Entry element:entrySet)
{
System.out.println(element.getKey()+element.getValue());
}
}
}
遍历
package com.xm.study.Map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Student遍历 {
public static void main(String[] args) {
Map map=new HashMap<>();
Student s1=new Student("肖猛",12);
Student s2=new Student("东旭",13);
Student s3=new Student("肖紫嫣",10);
map.put("1号",s1);
map.put("2号",s2);
map.put("3号",s3);
//遍历1
Set keySet = map.keySet();
for(String key:keySet)
{
System.out.println(key+map.get(key).getName()+map.get(key).getAge());
}
System.out.println("---------");
//遍历2
Set> entries = map.entrySet();
for(Map.Entry element :entries)
{
// System.out.println(element.toString());
System.out.println(element.getKey()+element.getValue().getName()+element.getValue().getAge());
}
}
}
Array List集合存储Hash Map元素并遍历
package com.xm.study.Map;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class ArrayList存储HashMap元素并遍历 {
public static void main(String... args) {
Map map1 = new HashMap<>();
map1.put("01", "肖猛");
map1.put("02", "李伟晴");
map1.put("03", "what");
Map map2 = new HashMap<>();
map2.put("01", "肖猛1");
map2.put("02", "李伟晴1");
map2.put("03", "what1");
Map map3 = new HashMap<>();
map3.put("01", "肖猛2");
map3.put("02", "李伟晴2");
map3.put("03", "what2");
ArrayList
Hash Map 集合存储Array List元素并遍历
package com.xm.study.Map;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class HashMap存储ArrayList元素并遍历 {
public static void main(String[] args) {
Map> map = new HashMap<>();
ArrayList arrayList = new ArrayList<>();
ArrayList arrayList1 = new ArrayList<>();
ArrayList arrayList2 = new ArrayList<>();
arrayList.add("你好嘛");
arrayList.add("我很好");
arrayList.add("你呢");
arrayList.add("我也是");
arrayList1.add("你好嘛1");
arrayList1.add("我很好1");
arrayList1.add("你呢1");
arrayList1.add("我也是1");
arrayList2.add("你好嘛2");
arrayList2.add("我很好2");
arrayList2.add("你呢2");
arrayList2.add("我也是2");
map.put(1, arrayList);
map.put(2, arrayList1);
map.put(3, arrayList2);
//方式一
Set>> entrySet = map.entrySet();
for (Map.Entry> element : entrySet) {
int key = element.getKey();
ArrayList value = element.getValue();
System.out.println("键为" + key + "对应为arraylist" + (key - 1) + "集合");
System.out.println("此集合中对应的元素:");
for (String s : value)
System.out.print(s + " ");
System.out.println();
}
System.out.println("-----------------------");
//方式二
Set keySet = map.keySet();
for(Integer i :keySet)
{
System.out.println("键为" + i + "对应为arraylist" + (i - 1) + "集合");
ArrayList list = map.get(i);
for(String s:list)
{
System.out.println("键"+i+"对应的集合中的元素:"+s);
}
}
}
}
Collections工具类
功能:
package com.xm.study.Collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class A {
public static void main(String[] args) {
List list=new ArrayList<>();
list.add(30);
list.add(20);
list.add(40);
list.add(30);
list.add(10);
list.add(70);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
Collections.reverse(list);
System.out.println(list);
//随机置换
Collections.shuffle(list);
System.out.println(list);
}
}
Array List中的排序:
package com.xm.study.Collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Demo1 {
public static void main(String... args) {
ArrayList arrayList=new ArrayList<>();
Student s1=new Student("liumeng",40);
Student s2=new Student("abcdye",40);
Student s3=new Student("xiaomeng",40);
Student s4=new Student("weare",40);
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
arrayList.add(s4);
Collections.sort(arrayList, (Student thiss, Student befores)-> {
int num=thiss.getAge()-befores.getAge();
int num2=num==0?thiss.getName().compareTo(befores.getName()):num;
return num2;
}
);
for(Student student:arrayList)
System.out.println(student.getName()+student.getAge());
}
}
未排序斗地主:
package com.xm.study.Collections;
import java.util.ArrayList;
import java.util.Collections;
public class FightTheLandlord {
public static void main(String[] args) {
ArrayList array = new ArrayList<>();
String[] color = {"♦", "♥", "♣", "♠"};
String[] number = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
String bigBos = "大王", smallBos = "小王";
for (String colors : color)
for (String num : number)
array.add(colors + num);
array.add(bigBos);
array.add(smallBos);
Collections.shuffle(array);
ArrayList number1 = new ArrayList<>();
ArrayList number2 = new ArrayList<>();
ArrayList number3 = new ArrayList<>();
ArrayList diPai = new ArrayList<>();
for (int i = 0; i < array.size(); i++) {
String poKer = array.get(i);
if (i >= array.size() - 3)
diPai.add(poKer);
else if (i % 3 == 0)
number1.add(poKer);
else if (i % 3 == 1)
number2.add(poKer);
else
number3.add(poKer);
}
ShowPoKer("肖猛:", number1);
ShowPoKer("李伟晴:", number2);
ShowPoKer("东旭:", number3);
ShowPoKer("底牌:", diPai);
}
public static void ShowPoKer(String name, ArrayList array) {
System.out.print(name + "的牌示:");
for (String poker : array)
System.out.print(poker + " ");
System.out.println();
}
}
肖猛:的牌示:♣6 ♠Q ♥10 ♠10 ♥8 ♣5 ♦9 ♣7 ♠K ♥A ♠6 ♣10 ♠5 ♥6 ♠8 ♣A ♦K 李伟晴:的牌示:♣4 小王 ♦3 ♣J ♥5 ♠A ♣K ♣9 ♦J ♠4 ♦4 ♦2 ♠9 ♥9 ♦8 ♦5 ♠J 东旭:的牌示:♦10 ♥Q 大王 ♠3 ♥7 ♦Q ♥J ♠7 ♥K ♦A ♥3 ♠2 ♣3 ♣2 ♦7 ♥4 ♦6 底牌:的牌示:♥2 ♣Q ♣8排序斗地主:
package com.xm.study.Collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
public class UpGradeLandlords {
public static void main(String[] args) {
HashMap map = new HashMap<>();
ArrayList array = new ArrayList<>();
String[] colors = {"♦", "♥", "♣", "♠"};
String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
int index = 0;
for (String num : numbers)
for (String color : colors) {
map.put(index, color + num);
array.add(index);
index++;
}
map.put(index, "小王");
array.add(index);
map.put(index + 1, "大王");
array.add(index + 1);
Collections.shuffle(array);
TreeSet player1 = new TreeSet<>();
TreeSet player2 = new TreeSet<>();
TreeSet player3 = new TreeSet<>();
TreeSet diPai = new TreeSet<>();
for (int i = 0; i < array.size(); i++) {
int x = array.get(i);
if (i >= array.size() - 3)
diPai.add(x);
else if (i % 3 == 0)
player1.add(x);
else if (i % 3 == 1)
player2.add(x);
else
player3.add(x);
}
ShowPoKer("肖猛:", player1, map);
ShowPoKer("李伟晴:", player2, map);
ShowPoKer("东旭:", player3, map);
ShowPoKer("底牌:", diPai, map);
}
public static void ShowPoKer(String name, TreeSet treeSet, HashMap map) {
System.out.print(name + "的牌示:");
for (int key : treeSet)
System.out.print(map.get(key) + " ");
System.out.println();
}
}
肖猛:的牌示:♣3 ♠4 ♦5 ♠5 ♥6 ♣7 ♦8 ♦9 ♥9 ♠9 ♣10 ♣J ♦Q ♥Q ♠Q ♥A ♥2 李伟晴:的牌示:♥3 ♦4 ♣4 ♣6 ♥7 ♠7 ♠8 ♣9 ♥10 ♠10 ♥J ♣Q ♥K ♣K ♦2 ♣2 ♠2 东旭:的牌示:♦3 ♠3 ♥4 ♥5 ♣5 ♦6 ♠6 ♣8 ♦10 ♦J ♠J ♦K ♠K ♦A ♠A 小王 大王 底牌:的牌示:♦7 ♥8 ♣A异常处理



