package collections.testcollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import collections.collection.Course;
/**
* 集合框架分两大类：List和Map，此类是测试：List（主要实现类是ArraryList）
*
* 当前类测试【List】的方法有：
*
* 一、测试添加方法、数组转列表方法，获取下标方法
* -1.add(E e) :将指定的元素追加到此列表的末尾（可选操作）。
* -2.list.indexOf(obj):获取当前元素的下标：返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
* -3.add(int index, E element) :将指定的元素插入此列表中的指定位置（可选操作）。
* -4.Arrays.asList(obj):将参数obj（数组），转换为列表
* -5.addAll(Collection<? extends E> c) :按指定集合的迭代器（可选操作）返回的顺序将指定集合中的所有元素附加到此列表的末尾。
* -6.addAll(int index, Collection<? extends E> c) :将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。
*
* 二、删除
* -7.remove(int index) :删除该列表中指定位置的元素。
* removerAll :从此列表中删除包含在指定集合中的所有元素
* retainAll(Collection<?> c) 仅保留此列表中包含在指定集合中的元素
* -8.boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）（可选操作）。
* -9.boolean removeAll(Collection<?> c) :从此列表中删除包含在指定集合中的所有元素（可选操作）。
* -10.clear():从此列表中删除所有元素（可选操作）。
*
* 三、查询--遍历集合
* -11.for循环
* -12.foreach循环
* -13.iterator() 以正确的顺序返回该列表中的元素的迭代器。
* 此外还有get(index)按下标查询等简单方法
*
*
* 四、各种判断方法是否存在?有个问题，重写equals方法?
* -14.boolean contains(Object o)：如果此集合包含指定的元素，则返回true 。
* -15.boolean containsAll(Collection<?> c)：如果此集合包含指定 集合中的所有元素，则返回true。
*
* 五、修改
* -16.set(int index, E element) 用指定的元素（可选操作）替换此列表中指定位置的元素。
*
* 六、排序
* sort
* 其他的方法
* -17.replaceAll(UnaryOperator<E> operator) :将该列表的每个元素替换为将该运算符（operator）应用于该元素的结果。
*
*/
public class TestList {
// 类属性--待选课程集合,此属性的类型是Coure（本身即是一个类）
public List<Course> coursesToSelect ;//使用泛型
// 利用构造器来初始化couresToSelect,ArrayList是List的实现类，因为List是接口，接口不能被实例化
public TestList(){
this.coursesToSelect = new ArrayList<Course>();//注意泛型
}
/**
* 基础的数据
*/
public void newData(){
Course c1 = new Course("1", "课程一");
Course c2 = new Course("2", "课程二");
Course c3 = new Course("3", "课程三");
Course c4 = new Course("4", "课程四");
Course c5 = new Course("5", "课程五");
Course c6 = new Course("6", "课程六");
coursesToSelect.add(c1);
coursesToSelect.add(c2);
coursesToSelect.add(c3);
coursesToSelect.add(c4);
coursesToSelect.add(c5);
}
/**
* 方便查看集合
*/
public void testForeach(){
for (Course course : coursesToSelect) {
System.out.println(course.getName());
}
}
/**
* 一、测试添加方法、数组转列表方法，获取下标方法
*/
public void testAdd(){
// 通过实例化课程类（Course），新建课程对象，以便放入集合coursesToSelect中
Course c1 = new Course("1", "课程一");
Course c2 = new Course("2", "课程二");
//1.add(E e) :将指定的元素追加到此列表的末尾（可选操作）。
coursesToSelect.add(c1);
System.out.print("添加了课程：");
System.out.print(coursesToSelect.get(0).getId()+":"+coursesToSelect.get(0).getName());
// 结果--添加了课程：1:课程一
System.out.println();
//2.获取当前元素的下标：list.indexOf(obj)
System.out.println("此时课程一的下标为："+coursesToSelect.indexOf(c1));
// 结果--此时课程一的下标为：0
System.out.println("现在查询一个不存在的对象的下标，返回值为："+coursesToSelect.indexOf("dd"));
// 结果--现在查询一个不存在的对象的下标，返回值为：-1
System.out.println();
//3.add(int index, E element) 将指定的元素插入此列表中的指定位置（可选操作）。
coursesToSelect.add(0, c2);
System.out.print("添加了课程：");
System.out.print(coursesToSelect.get(0).getId()+":"+coursesToSelect.get(0).getName());
// 结果--添加了课程：2:课程二
System.out.println("--此时课程一的下标为："+coursesToSelect.indexOf(c1));
// 结果--此时课程一的下标为：1
System.out.println();
/*
* 4.Arrays.asList(obj):将参数obj（数组），转换为列表
* 5.addAll(Collection<? extends E> c)
* 6.addAll(int index, Collection<? extends E> c)
*/
// 新建数组---为方法4、5和6做准备
Course[] courses = {new Course("3", "课程三"),new Course("4", "课程四")};
Course[] courses2 = {new Course("5", "课程五"),new Course("6", "课程六")};
//4.Arrays.asList(obj):将参数obj（数组），转换为列表
List<Course> arrayToList = Arrays.asList(courses);//此时arrayToList是作为集合代替了数组courses
List<Course> arrayToList2 = Arrays.asList(courses2);//此时arrayToList是作为集合代替了数组courses
System.out.println();
//5.addAll(Collection<? extends E> c)
coursesToSelect.addAll(arrayToList);
System.out.println("新添加了"+coursesToSelect.get(2).getName()+"和"+coursesToSelect.get(3).getName());
// 新添加了课程三和课程四
System.out.println();
//6.addAll(int index, Collection<? extends E> c)
coursesToSelect.addAll(0,arrayToList2);
System.out.println("此时下标为0和1的课程："+coursesToSelect.get(0).getName()+"和"+coursesToSelect.get(1).getName());
// 此时下标为0和1的课程：课程五和课程六
}
/**
* 二、测试删除方法
*/
public void testDelete(){
//7.remove(int index) :删除该列表中指定位置的元素
System.out.println("删除前共有："+coursesToSelect.size()+"个元素，下标为0的是"+coursesToSelect.get(0).getName());
coursesToSelect.remove(0);
System.out.println("删除下标为0的元素后，共有"+coursesToSelect.size()+"个元素下标为0的是"+coursesToSelect.get(0).getName());
System.out.println();
//8.boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在)
//获取index=0的对象
Course obj = coursesToSelect.get(0);
System.out.println("调用boolean remove(Object o)前，下标0"+coursesToSelect.get(0).getName());
System.out.println("从列表中删除指定元素的第一个出现（如果存在）:"+coursesToSelect.remove(obj));
System.out.println("调用boolean remove(Object o)后，下标0"+coursesToSelect.get(0).getName());
System.out.println();
//9.boolean removeAll(Collection<?> c) :从此列表中删除包含在指定集合中的所有元素
Course[] courses = {new Course("3", "课程三"),new Course("4", "课程四")};
List<Course> arrayToList2 = Arrays.asList(courses);//此时arrayToList是作为集合代替了数组courses
System.out.println(arrayToList2.size());
System.out.println(coursesToSelect.removeAll(arrayToList2));
System.out.println(coursesToSelect.size());
System.out.println(arrayToList2.size());
System.out.println();
//10.clear():从此列表中删除所有元素
System.out.println("此时集合courseToSelect的长度为:"+coursesToSelect.size());
coursesToSelect.clear();
System.out.println("调用clear()方法后此时集合courseToSelect的长度为:"+coursesToSelect.size());
}
/**
* 三、遍历集合
*/
public void testErgodic(){
// 添加数据
newData();
//11.普通for循环
System.out.println();
System.out.println("普通for循环遍历集合");
for (int i = 0; i < coursesToSelect.size(); i++) {
System.out.println(" " + coursesToSelect.get(i).getId()+" : "+coursesToSelect.get(i).getName());
}
System.out.println();
//12.foreach循环
System.out.println("foreach循环");
for (Course course : coursesToSelect) {
System.out.println(course.getId()+" : "+course.getName());
}
System.out.println();
//iterator() 以正确的顺序返回该列表中的元素的迭代器。
System.out.println("iterator()迭代器遍历集合");
//第一步:创建迭代器对象
Iterator it = coursesToSelect.iterator();
//第二步：通过循环迭代
//hasNext():判断是否存在下一个元素
while(it.hasNext()){
Course obj = (Course) it.next();
System.out.println(obj.getName());
}
}
/**
* 四、判断方法（是否包含等方法）-有疑问。contains返回true和false
*/
public void testBoolean(){
newData();
//14.boolean contains(Object o)：如果此集合包含指定的元素，则返回true
// 判断一个对象是否在容器中
// 判断标准： 是否是同一个对象，而不是name是否相同
Course newc6 = new Course("6", "课程一");
Course newc7 = new Course("3", "课程单独二");
System.out.println(coursesToSelect.contains(newc6));
System.out.println(coursesToSelect.contains(newc7));
// ？直接调用contains方法会依次比较内容，有相同的就返回true，因为此时每个对象里面有两个小对象定义的属性相同，？所有有一个相同就true？
// ？自己定义的元素，应该重写equals()方法！这里和预想有误
//15.boolean containsAll(Collection<?> c)
List<Course> testList = new ArrayList<Course>();
Course newc8 = new Course("1", "课程一");
Course newc9 = new Course("3", "课程三");
coursesToSelect.add(newc8);
coursesToSelect.add(newc9);
testList.add(newc8);
testList.add(newc9);
System.out.println(coursesToSelect.contains(testList));//数值相同，但是对象不同，所以也是返回false
testForeach();
}
/**
* 五、修改
*/
public void testSet(){
newData();
//set(int index, E element)
Course c6 = new Course("6", "课程六");
coursesToSelect.set(0, c6);
testForeach();//修改了第一个课程
}
/**
* 17..replaceAll(UnaryOperator<E> operator) :将该列表的每个元素替换为将该运算符（operator）应用于该元素的结果。
*/
public void testReplaceAll(){
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
System.out.println("一开始list："+list);
// replaceAll是Collections的方法
Collections.replaceAll(list, 1, 111);
System.out.println(list);
}
/**
* sort
*/
public void testSort(){
List<Integer> nums = new ArrayList<Integer>();
nums.add(3);
nums.add(5);
nums.add(1);
nums.add(0);
System.out.println(nums);
Collections.sort(nums);
System.out.println(nums);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
TestList testList = new TestList();
System.out.println("-----------调用方法testAdd()-----------");
// testList.testAdd();
System.out.println();
System.out.println("-----------调用方法testDelete()-----------");
// testList.testDelete();
System.out.println();
System.out.println("-----------调用方法testErgodic()-----------");
// testList.testErgodic();
System.out.println();
System.out.println("-----------调用testBoolean()");
// testList.testBoolean();
System.out.println();
System.out.println("-----------调用testSet()");
// testList.testSet();
System.out.println();
System.out.println("-----------调用testReplaceAll()");
// testList.testReplaceAll();
System.out.println();
System.out.println("-----------调用testSort()");
testList.testSort();
System.out.println();
}
}
网友评论