【集合概念】
1.类中属性类型相同，意义与作用也相同，就可以放到集合中
2.数组的长度是固定的，集合的长度或者容量在使用时可以动态扩展的
3.Collection接口和Map接口
4.Collection:序列List(元素排列有序可重复，实现类ArrayList,数组序列) 队列Queue(元素排列有序可重复，实现类LinkedList,链表也是List实现类) 集Set（无序不可重复 HashSet哈希集）
5.Map(实现类：HashMap 哈希表)内部类 Entry(键值对) 实例<Key,Value>
JAVA集合框架体系结构：Collection与Map是两个根接口。
Collection接口：内部存储的是一个个独立的对象。包含：
1、List接口：序列，存储元素排列有序且可重复。实现类:ArrayList，数组序列。实现类：LinkedList，链表。
2、Queue接口：队列，存储元素排列有序且可重复。实现类：LinkedList，链表。
3、Set接口：集，存储元素无序且不可重复。实现类：HashSet，哈希集。
Map接口：内部以<Key,Value>两个对象（任意类型）为一个映射去存储数据，这一个映射就是Entry类（Map的内部类）的实例。包括：实现类：HashMap，哈希表。
Collection(接口)
- List(接口)（特点：有序，可重复）
- ArrayList（实现类）
- LinkedList（实现类）
- Query(接口)（特点：有序，可重复）
- LinkedList（实现类）
- Set(接口)（特点：无序，不可重复）
- HashSet（实现类）
Map(接口)（特点：Entry(Key,Value) -- 键值对：)注：Entry是Map的内部类
- HashMap（实现类）
Collection接口是List、Set、Queue接口的父接口
Collection接口定义了可用于操作List、Set和Queue的方法--增删改查
List接口及其实现类--ArrayList
List是元素有序并且可以重复的集合，被称为序列。
List可以精确的控制每个元素的插入位置，或删除某个位置元素
List有add()插入方法和get()获取方法
ArrayList--数组序列，是List的一个重要实现类
ArrayList底层是由数组实现的，这也是其名字的由来
List是接口，所以在构造方法中不能直接实例化，而通过ArrayList()实例化。<br>
例：public List coursesToSelect = new ArrayList();<br>
调用Add()方法添加到List中。有两种方法：<br>
方法1：直接添加，例：CoursesToSelect.add(cr1);<br>
方法2：可以指定添加的位置，例：CoursesToSelect.add(0,cr1);<br>
使用get()方法取出一个对象，当一个对象被添加到集合中去的时候，它会被忽略掉类型，而都变成Object类型，取出时需要类型转换。<br>
例：Course temp = (Course)coursesToSelect.get(0);<br>
如果添加到List中的长度大于他目前的长度，则系统会出现异常，即数组下表越界异常<br>
addAll(Arrays.asList(数组名))的用法是：
1.创建一个对象数组并实例化。Course []course={new course(),new course()};
2.容器对象.addAll(Arrays.asList(对象数组名));
3.获取元素,定义一个Course对象来存储容器对象.get(index)的值 要类型转换。
Course temp=(Course)(CourseToSelect.get(index));
4.输出获取的值,System.out.println(temp.属性+temp.属性2);
list中还有addAll(List list)
就是将一个List里面的元素一股脑的全都加进去，妙哉妙哉
一般定义一个数组，如何把一个数组转换成List？ 调用方法Arrays.asList(Object[] obs);//可以将一个数组转换为一个List，然后可以将这个元素传进addAll()里面
当然还有addAll（index,List list）方法
removeAll直接传入一个list，同理
记得取出东西之后，要类型强转哦！！！因为取出来都是Object的。
向List中添加元素的几种方法：
新建List类
public List courseToSelect;
初始化List类
public ListTest()
{
this.courseToSelect=new ArrayList();
}
向List中添加数据
method_1
courseToSelect.add(对象1);
method_2
courseToSelect.add(位置,对象2);
method_3
courseToSelect.addAll(Arrays.asList(数组_对象3));
method_4
courseToSelect.addAll(位置,Arrays.asList(数组_对象4));
获取
Course temp=(Course)courseToSelect.get(位置);
List可以精确的控制每个元素的插入位置，多删除某个位置的元素
- ArrayList底层是由数组实现
list.add(对象)把一个对象添加到另一个集合的队尾位置
list.add(index, 对象) 把一个集合添加到另一个集合的指定位置
list.addAll(集合对象) 把一个集合添加到另一个集合的队尾位置
list.addAll(index, 集合对象) 把一个集合添加到另一个集合的指定位置
Arrays.asList(数组) 把一个数组转换成List集合
以下三种方法都是用来取出List中元素的方法：<br>
-----for循环-----<br>
public void testGet(){<br>
int size=coursesToSelect.size();<br>
for(int i=0;i<size;i++){<br>
Course cr=(Course) coursesToSelect.get(i);<br>
System.out.println("取出的课程："+cr.getId()+":"+cr.getName());<br>
}<br>
}<br>
-----迭代器-----<br>
Iterator是一个接口,依赖于集合存在的,本身不具备存储功能<br>
Iterator it=courseToSelect.iterator();<br>
while(it.hasNext()){<br>
Course cr=(Course) it.next();<br>
System.out.println("课程:" + cr.id + ":" + cr.name);<br>
}<br>
<br>
-----for each(增强for循环)-----<br>
<br>
凡是继承了Iterable接口的类所生成的对象都可以用for/each循环<br>
<br>
for(Object obj:coursesToSelect){//遍历集合中的每一个元素，作为每一个Object变量<br>
Course cr=(Course) obj;<br>
System.out.println("课程:" + cr.id + ":" + cr.name);<br>
}
package collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* @author Xinny
* @create 2021-09-29 11:48 上午
*/
public class ListTest {
//用于存放备选课程的list
public List coursesToSelect;
public ListTest() {
this.coursesToSelect = new ArrayList();
}
//添加课程
public void testInsert() {
//创建课程对象
Course c1 = new Course("1", "C++");
coursesToSelect.add(c1);
Course temp = (Course) coursesToSelect.get(0);
System.out.println("add" + temp.id + ":" + temp.name);
Course c2 = new Course("2", "Python");
coursesToSelect.add(0, c2);
Course temp2 = (Course) coursesToSelect.get(0);
System.out.println("添加了课程:" + temp2.id + ":" + temp2.name);
Course[] course = {
new Course("3", "Java"),
new Course("4", "Vue")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp3 = (Course) coursesToSelect.get(2);
Course temp4 = (Course) coursesToSelect.get(3);
System.out.println("add two course:" + temp3.id + ":" + temp3.name + ":" + temp4.id + ":" + temp4.name);
Course[] course2 = {new Course("5", "高数"), new Course("6", "大英")};
coursesToSelect.addAll(2, Arrays.asList(course2));
Course temp5 = (Course) coursesToSelect.get(2);
Course temp6 = (Course) coursesToSelect.get(3);
System.out.println("add two course：" + temp5.id + ":" + temp5.name + ":" + temp6.id + ":" + temp6.name);
}
public void testGet() {
int size = coursesToSelect.size();
System.out.println("now have：");
for (int i = 0; i < size; i++) {
Course cr = (Course) coursesToSelect.get(i);
System.out.println("course：" + cr.id + ":" + cr.name);
}
}
//通过迭代器来遍历list
public void testIterator() {
Iterator it = coursesToSelect.iterator();
System.out.println("now have:");
while (it.hasNext()) {
Course cr = (Course) it.next();
System.out.println("course：" + cr.id + ":" + cr.name);
}
}
//通过for each方法访问集合元素
public void testForEach() {
System.out.println("now have (for each):");
for (Object obj : coursesToSelect) {
Course cr = (Course) obj;
System.out.println("course: " + cr.id + ":" + cr.name);
}
}
//修改list中的元素
public void testModify(){
coursesToSelect.set(4,new Course("7","编译原理"));
}
//删除list中的元素
public void testDelete(){
//方法1
/**Course cr=(Course)coursesToSelect.get(4);
System.out.println("我是课程："+cr.id+";"+cr.name+",我即将被删除");
coursesToSelect.remove(cr);*/
//方法2
/**System.out.println("即将删除4位置上的课程");
coursesToSelect.remove(4);
System.out.println("成功删除课程！");*/
//方法3
System.out.println("delete index=4 and index = 5 course");
Course[] courses={(Course)coursesToSelect.get(4),(Course)coursesToSelect.get(5)};
coursesToSelect.removeAll(Arrays.asList(courses));//将数组转换为集合
System.out.println("delete success！");
testForEach();
}
public static void main(String[] args) {
ListTest it=new ListTest();
it.testInsert();
it.testGet();
it.testIterator();
it.testForEach();
it.testModify();
it.testForEach();
it.testDelete();
}
}删除元素)List中有remove(index),remove(对象值)和removeAll(Arrays.asList(对象数组名))方法来删除容器中元素的值(用法和add类似).
Course是信息课程类，有id和name属性。courseToSelect是list的序列容器对象。
1.remove(index);删除位置要大于0并且小于List(序列容器)的长度。如果要删除全部可以用for循环嵌套此方法。
2.remove(object);先要获得删除的值，用法是先定义一个信息变量通过get()来存放要删除的值,然后用remove(删除的对象值);
public void textdelect{
Course cr=(Course)(courseToSelect.get(4));
courseToSelect.remove(cr);//通过remove(对象值);
或者 courseToSelect.remove(4);//通过remove(删除位置); }
3.removeAll(Arrays.asList());要删除指定的多个位置 Arrays.asLIst(对象数组名);作用是把数组转换为集合
用法是先创建信息对象数组存放删除元素的值，然后再用removeAll(Arrays.asList(对象数组名))方法,删除集合数组的元素。
public void textdelext2{
Course []course={(Course)(courseToSelect.get(4)),(Course)(courseToSelect.get(5))}; // 定义数组存放要删除的值
courseToSelect.removeAll(Arrays.asList(course)); // 删除4和5位置的值 }
泛型<>;规定List定义的容器只能存储某种类型的元素。不用泛型的话是什么类型的元素都可以插入，因为插入集合是忽略其类型，把它看成为Object类型，取出时需要强行转换对应的类型。
编写带有泛型的集合
List<Course> courseToSelect;
在构造方法中(实例化的时候也可以不在构造方法，直接实例就可以)
this.courseToSelect=new ArrayList<Course>(); //带有泛型-Course的List类型属性就创建了
泛型集合中，不能添加泛型规定的类型以及其子类型以外的对象，否则会报错。
运用了泛型的话，用foreach语句时 存储变量应该为泛型的类型。for(Course a:courseToSelect),不必再用Object取出再强转，因为已经规定容器里装的都是Course类型。
总结关于list类型的一下用法：
1.创建对象
List list = new ArrayList();
2.向list对象中添加数据
（1）Course crre = new Course("1","数据结构");//一个类的对象
list.add(crre);//将对象添加到list中
（2）Course[] crre = {new Course("",""),new Course("","");//对象的数组
list.addAll(0,Arrays.asList(course));//切记Arrays.asList方法
3.获取集合中的元素
（1）Course temp = (Course)list.get(0);//注意强转
（2）Iterator it = list.iterator();
while(it.hasNext()){
Course cr = (Course)it.next();//迭代遍历，使用iterator方法
}
（3）for(Object obj:list){
Course cr = (Course)obj;
}//foreach方法 ，注意Object的使用
4.集合中参数的修改
list.set(2,new Course("",""));
5.集合中数据的删除
(1)list.remove(位置）;
(2)Course[] crr = {(Course)list.get(位置）(Course)list.get(位置）}；
list.removeAll(Arrays.asList(crr));//参考addAll
6.带有泛型的list
List<Course> course = new ArrayList<Course>();//相当于添加进去的元素有了具体类型，不再是Object
7.list可以添加子类型的对象
8.list不能直接添加基本类型（int,float等）的对象，如果要添加，需要使用其包装类
Set接口及其实现类——HashSet
Set是元素无序并且不可以重复的集合，被称为集；
HashSet——哈希集，是Set的一个重要实现类。
1、Set没有像List中set()方法一样就修改，因为List是有序的，可以指定位置，而Set是无序的。
2、查询遍历时，Set不能用get()方法去获取，因为无序没有指定索引ID，但可以使用foreach和iterator来遍历，但是每次遍历出来可能顺序都不一样，还是因为无序造成的。
3、Set中的size(),add(),addAll(),remove(),removeAll()与List类似。
4、Set还可以添加null；无序演示（如图）
Map接口
1. Map接口提供了一中映射关系，其中的元素是键值对（key-value）的形式存储的，能够实现根据Key快速查找value。Key-value可以是任何对象，是以Entry类型的对象实例存在的。
2.Key是不可以重复的，Value是可以重复的。Key-value都可以为null，不过只能有一个key是null。
3.map支持泛型，Map<K,V>
4.每个键最多只能映射到一个值
5.Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法
6.通过put<K key,V value>,remove<Object key>操作数据
7.HashMap中的Entry对象是无序排列的，HashMap是Map的一个重要实现类，也是最常用的，基于哈希表是实现
Collection集合中的公用方法
①.cointains方法--------返回值为boolean，测试集合中是否存在某个元素
②.indexof方法----------测试集合中某个元素第一次出现的的位置。如果元素不存在返回-1
③.lastIndexof方法------测试集合中某个元素最后一次出现的位置。如果元素不存在返回-1
⑤.size方法-------------测试集合的容量大小
⑥.在Map中，用containsKey()方法来判断是否包含某个key值。返回值为true，则包含。
⑦.在Map中，用containsValue()方法来判断是否包含某个value值。
集合的indexof方法去找元素的位置，数组可以直接转成集合，修改也有直接修改的方法。
Map映射表
一、判断是否包含某个Key值：containsKey()
二、判断是否包含某个Value值：containsValue()
1、同样是以每一个元素的value值的equals方法进行比较，所以需要重写value类的equals()方法来进行属性（某个）比较
关于Student的hashCode和equals 方法重写：
没有重写之前是比较的新建对象所在的内存空间 而重写之后则是比较两个类对象是否相同
一、compareable 是默认比较规则， comparator是临时比较规则
1.Comparable接口------可比较的
实现该接口表示：这个类的实例可以比较大小，可以进行自然排序
定义了默认的比较规则
其实现类需实现compareTo()方法
comparaTo()方法返回正数表示大，负数表示小，0表示相等
2.Comparator接口-----比较工具接口
用于定义临时比较规则，而不是默认比较规则
其实现类需要实现compare()方法
Comparator和Comparable都是Java集合框架的成员
compareable 需要实现compare to方法， comparator需要实现 compare方法
三、Java集合框架：
Collection接口，Map接口，Collections工具类，Comparable接口，Comparator接口
主类第四段：
Collections.sort(array);
//判断1玩家的最大手牌
ArrayList<String> array1=new ArrayList<String>();
array1.add(al.get(0));
array1.add(al.get(2));
Collections.sort(array1);
//判断1玩家的最大手牌
ArrayList<String> array2=new ArrayList<String>();
array2.add(al.get(1));
array2.add(al.get(3));
Collections.sort(array2);
//输出玩家1的最大手牌
for(int i=0;i<ch.length;i++){
if(array1.get(1).equals(ch[i])){
System.out.println("玩家："+alwj.get(0).name+"的最大手牌为:"+str[i]);
}
}
//输出玩家2的最大手牌
for(int i=0;i<ch.length;i++){
if(array2.get(1).equals(ch[i])){
System.out.println("玩家："+alwj.get(1).name+"的最大手牌为:"+str[i]);
}
}
//判断玩家谁获胜
if(array.get(3).equals(al.get(0))||array.get(3).equals(al.get(2))){
System.out.println("*********玩家："+alwj.get(0).name+"获胜!**********");
}else{
System.out.println("*********玩家："+alwj.get(1).name+"获胜!**********");
}
1282
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
