day16集合
需求:
集合框架(去除ArrayList中重复字符串元素方式)(掌握)
ArrayList去除集合中字符串的重复值(字符串的内容相同)
* 思路:创建新集合方式
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("a");
list.add("a");
list.add("b");
list.add("c");
list.add("c");
list.add("c");
System.out.println(list);
ArrayList newList = getSingle(list);
System.out.println(newList);
}
/*
* 去除重复
* 1,返回ArrayList
* 2,参数列表ArrayList
*/
public static ArrayList getSingle(ArrayList list) {
ArrayList newList = new ArrayList(); //创建一个新集合
Iterator it = list.iterator(); //获取迭代器
while(it.hasNext()) { //判断老集合中是否有元素
String temp = (String)it.next(); //将每一个元素临时记录住
if(!newList.contains(temp)) { //如果新集合中不包含该元素
newList.add(temp); //将该元素添加到新集合中
}
}
return newList; //将新集合返回
}
集合框架(去除ArrayList中重复自定义对象元素)(掌握)
去除ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
重写equals()方法的
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
}
因为Contains 方法中依赖的是equals方法,而在自定义的new 出来的每个地址都不一样,所有要复写equals方法。 getSingle方法代码同上
集合框架(LinkedList的特有功能)(掌握)
* B:LinkedList类特有功能
* public void addFirst(E e)及addLast(E e)
* public E getFirst()及getLast()
* public E removeFirst()及public E removeLast()
* public E get(int index);
###16.04_集合框架(栈和队列数据结构)(掌握)
* 栈 先进后出
* 队列 先进先出
根据此。我们可以做一个(用LinkedList模拟栈数据结构的集合并测试)
public class Stack {
private LinkedList list = new LinkedList();
/*
* 模拟进栈方法
*/
public void in(Object obj) {
list.addLast(obj);
}
/*
* 模拟出栈
*/
public Object out() {
return list.removeLast();
}
/*
* 模拟栈结构是否为空
*/
public boolean isEmpty() {
return list.isEmpty();
}
}
测试
public static void main(String[] args) {
//demo1();
Stack s = new Stack();
s.in("a"); //进栈
s.in("b");
s.in("c");
s.in("d");
while(!s.isEmpty()) { //判断栈结构是否为空
System.out.println(s.out()); //弹栈
}
}
结果:d
c
b
a
16.06_集合框架(泛型概述和基本使用)(掌握)
* A:泛型概述
* B:泛型好处
* 提高安全性(将运行期的错误转换到编译期)
* 省去强转的麻烦
* C:泛型基本使用
* <>中放的必须是引用数据类型
* D:泛型使用注意事项
* 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)
ArrayList<Person> list = new ArrayList<Person>();
list.add(new Person("张三", 23));
list.add(new Person("李四", 24));
Iterator<Person> it = list.iterator();
while(it.hasNext()) {
Person p = it.next(); //不用转型了
System.out.println(p.getName() + "..." + p.getAge())
存储一个字符串并且遍历
ArrayList<String> list = new ArrayList<>(); //创建集合对象
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
###16.09_集合框架(泛型类的概述及使用)(了解)
* A:泛型类概述<T>
* 把泛型定义在类上
* B:定义格式
* public class 类名<泛型类型1,…>
* C:注意事项
* 泛型类型必须是引用类型
* D:案例演示
* 泛型类的使用
泛型类
public class Tool<Q> { //泛型方法
private Q q;
public Q getObj() {
return q;
}
public void setObj(Q q) {
this.q = q;
}
//泛型方法
public<T> void show(T t) { //方法泛型最好与类的泛型一致
System.out.println(t); //如果不一致,需要在方法上声明该泛型
}
public static<W> void print(W w) { //静态方法必须声明自己的泛型
System.out.println(w);
}
}
实现
public static void main(String[] args) {
Tool<String> t = new Tool<>();
t.show(true); //打印出来就是show
Tool<Student> tt = new Tool<>(); //创建工具类对象
tt.setObj(new Student("张三",23));
Student s=tt.getQ();
System.out.println(s.getName()+" "+s.getAge());
集合框架(泛型接口的概述和使用)(了解)
* A:泛型接口概述
* 把泛型定义在接口上
* B:定义格式
* public interface 接口名<泛型类型>
* C:案例演示
* 泛型接口的使用
定义一个泛型接口
public interface InfoDemo<T>{
public T getVar(); //都是抽象方法
}
一个类来实现它
public class InfoDemoImp implements InfoDemo<String> {
private String var;
public InfoDemoImp(String var){
this.setVar(var);
}
public void setVar(String var){
this.var=var;
}
@Override
public String getVar() {
// TODO Auto-generated method stub
return this.var;
}
}
}
//找一个类来测试一下
public static void main(String[] args) {
// TODO Auto-generated method stub
InfoDemo w=new InfoDemoImp("liguo");
System.out.println("内容是"+w.getVar());
}
结果是:liguo
集合框架(泛型高级之通配符)
* A:泛型通配符<?>
* 任意类型,如果没有明确,那么就是Object以及任意的Java类了
* B:? extends E
* 向下限定,E及其子类
* C:? super E
* 向上限定,E及其父类
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<Person> l1=new ArrayList<>();
l1.add(new Person("这哪个房",11));
l1.add(new Person("什么",12));
ArrayList<Student> l2=new ArrayList<>();
l2.add(new Student("liguo",15));
l2.add(new Student("liziqi",16));
l1.addAll(l2);
System.out.println(l1);
因为Person 是student 的父类,所以才可以添加
数组转换集合或者集合转数组
public static void demo1(){ //数组转换成集合
Integer[] ar={5,6,52,96};
List<Integer> l=Arrays.asList(ar); //包装类型
System.out.println(l);
}
public static void demo2(){
String[] arr={"liy","lifnag"};
List<String> li = Arrays.asList(arr);
System.out.println(li);
}
public static void demo3() {
int[] ii = { 5, 6, 8, 74 };
List<int[]> fo = Arrays.asList(ii); //看这个泛型类型就不一样了。
System.out.println(fo);
}
需求
/**
* * A:案例演示
* 集合嵌套之ArrayList嵌套ArrayList
* 案例:
* 我们学科,学科又分为若个班级
* 整个学科一个大集合
* 若干个班级分为每一个小集合
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<ArrayList<Person>> a=new ArrayList<>();
ArrayList<Person> first=new ArrayList<>();
first.add(new Person("杨幂", 30));
first.add(new Person("李冰冰", 33));
first.add(new Person("范冰冰", 20));
ArrayList<Person> second=new ArrayList<>();
second.add(new Person("黄晓明", 31));
second.add(new Person("赵薇", 33));
second.add(new Person("陈坤", 32));
//将班级添加到学科集合中
a.add(first);
a.add(second);
//遍历学科集合
for(ArrayList<Person> f:a){
for(Person p:f){
System.out.println(p);
}
}
}
集合框架(可变参数的概述和使用)(掌握)
* A:可变参数概述
* 定义方法的时候不知道该定义多少个参数
* B:格式
* 修饰符 返回值类型 方法名(数据类型… 变量名){}
* C:注意事项:
* 这里的变量其实是一个数组
* 如果一个方法有可变参数,并且有多个参数,那么,可变参数肯定是最后一个
集合框架(三种迭代的能否删除)(掌握)
* 普通for循环,可以删除,但是索引要--
* 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
* 增强for循环不能删除
/**
* * A:增强for概述
* 简化数组和Collection集合的遍历
* B:格式:
*
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可,该变量就是元素
}
* C:案例演示
* 数组,集合存储元素用增强for遍历
* D:好处
* 简化遍历
增强for循环底层依赖的是迭代器(Iterator)
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
//1,普通for循环删除,索引要--
/* for(int i=0;i<list.size();i++){
if("b".equals(list.get(i))){
list.remove(i--); //这个可以的
}
}
}*/
//2,迭代器删除
/*Iterator<String> it = list.iterator();
while(it.hasNext()) {
if("b".equals(it.next())) {
//list.remove("b"); //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
it.remove(); //这个可以的
}
}*/
//3,增强for循环,增强for循环不能删除,只能遍历
for(String s:list){
if("b".equals(s)){
list.remove("b");
}
}
System.out.println(list);
}