——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
16.01_集合框架(去除ArrayList中重复字符串元素方式1)
A:案例演示
- 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
思路：创建新集合方式
/** * A:案例演示 * 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同) * 思路：创建新集合方式 */ public static void main(String[] args) { ArrayList list = new ArrayList(); list.add("a"); list.add("a"); list.add("b"); list.add("b"); list.add("b"); list.add("c"); 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; //将新集合返回 }
16.02_集合框架(去除ArrayList中重复自定义对象元素)
- A:案例演示
- 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
- B:注意事项
- 重写equals()方法的
public static void main(String[] args) {
// 1.创建一个ArrayList集合
ArrayList<Student> list = new ArrayList<Student>();
// 2.向集合中添加元素
Student s1 = new Student(1, "tom");
Student s2 = new Student(2, "fox");
Student s3 = new Student(3, "james");
Student s4 = new Student(2, "fox");
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
// 3.判断集合中是否有重复的元素，如果有重复remove。
// 问题:ArrayList集合中元素的重复，“重复”的概念是什么?
// /我们需要重写equals方法.
// 问题:怎样重写equals?
// Student s5 = new Student(2, "fox");
// System.out.println(list.contains(s5));
for (int i = 0; i < list.size() - 1; i++) {
for (int j = i + 1; j < list.size(); j++) {
Student ss1 = (Student) list.get(i);
Student ss2 = (Student) list.get(j);
if (ss1.equals(ss2)) { // ss1==ss2
// 注意:如果重定了equals方法，在比较时，就比较的是属性。
list.remove(j);
j--;
}
}
}
System.out.println(list);
}
}
// 补充:如果使用contains方法来判断 是否重复，也需要重写equals方法。
class Student {
private int id;
private String name;
public Student(int id, String name) {
super();
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
// alt+shift+s 选择重写hashCode与equals方法，选择比较的属性.
// @Override
// public boolean equals(Object obj) {
// if (this == obj)
// return true;
// if (obj == null)
// return false;
// if (getClass() != obj.getClass())
// return false;
// Student other = (Student) obj;
// if (id != other.id)
// return false;
// if (name == null) {
// if (other.name != null)
// return false;
// } else if (!name.equals(other.name))
// return false;
// return true;
// }
// 重写equals方法----->必须比较所有属性.
// @Override
// public boolean equals(Object obj) {
// if (obj == null) {
// return false;
// }
// // 1.判断一下obj是否是Student
// if (obj instanceof Student) {
// Student s = (Student) obj;
//
// // 2.比较对象的所有属性是否相等
// if (this.id == s.id && this.name.equals(s.name)) {
// return true;
// }
// }
//
// return false;
// }16.03_集合框架(LinkedList的特有功能)
- A: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_集合框架(栈和队列数据结构)
- 栈
- 先进后出
- 队列
- 先进先出
16.05_集合框架(用LinkedList模拟栈数据结构的集合并测试)
A:案例演示
- 需求：请用LinkedList模拟栈数据结构的集合，并测试
- 创建一个类将Linked中的方法封装
public class Stack { private LinkedList list = new LinkedList(); //创建LinkedList对象 public void in(Object obj) { list.addLast(obj); //封装addLast()方法 } public Object out() { return list.removeLast(); //封装removeLast()方法 } public boolean isEmpty() { return list.isEmpty(); //封装isEmpty()方法 } }
LinkedList ll = new LinkedList();
ll.addFirst("a"); // 使用addFirst方法
ll.addFirst("b");
ll.addFirst("c");
// 先装入的数据在最下边.
// 2.取数据时
while (!ll.isEmpty()) { // 只要集合不为空循环就执行
String s = (String) ll.removeFirst();
System.out.println(s);
}16.06_集合框架(泛型概述和基本使用)
- A:泛型概述//jdk1.5新特性,用于约束类型
- B:泛型好处
- 提高安全性(将运行期的错误转换到编译期)
- 省去强转的麻烦
- C:泛型基本使用
- <>中放的必须是引用数据类型
- D:泛型使用注意事项
- 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型<>)
16.07_集合框架(ArrayList存储字符串和自定义对象并遍历泛型版)
- A:案例演示
- ArrayList存储字符串并遍历泛型版
List<String> list = new ArrayList<String>(); // 3所以规定list集合中只能装入String
// list.add(10);
list.add("tom");
// list.add(new Date());//1如果存这个的话
for (int i = 0; i < list.size(); i++) {
String s = (String) list.get(i); // 2会报一个ClassCastException 类型转换问题
System.out.println(s);// a手动添加为了不报错
}16.08_集合框架(泛型的由来)
- A:案例演示
- 泛型的由来:通过Object转型问题引入
- 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
16.09_集合框架(泛型类的概述及使用)
- A:泛型类概述 < T >
- 把泛型定义在类上
- B:定义格式
- public class 类名<泛型类型1,…>
- C:注意事项
- 泛型类型必须是引用类型
- D:案例演示
- 泛型类的使用
//泛型类
public class GenericDemo6 {
public static void main(String[] args) {
GenericUtils1<String> gu1 = new GenericUtils1<String>();
gu1.print("hello world");
GenericUtils1<Integer> gu11 = new GenericUtils1<Integer>();
gu11.print(10);
}
}
// 工具类
class GenericUtils1<T> { // 在类上声明泛型
T t;// 成员属性
//static T t; //报错
// 有一个打印方法，可以将任意对象打印
public void print(T t) { // 成员方法
}
// public static void print(T t) 报错
}16.10_集合框架(泛型方法的概述和使用)
- A:泛型方法概述
- 把泛型定义在方法上
- B:定义格式
- public <泛型类型> 返回类型 方法名(泛型类型 变量名)
- C:案例演示
- 泛型方法的使用
public static <E> E show(E t) {
return null;
}16.11_集合框架(泛型接口的概述和使用)
- A:泛型接口概述
- 把泛型定义在接口上
- B:定义格式
- public interface 接口名<泛型类型>
- C:案例演示
- 泛型接口的使用
public class GenericDemo8<T> { // 在类上声明泛型
public static void main(String[] args) {
Animal<Bone> dog=new Dog<Bone>();
dog.eat(new Bone());
}
}
interface Animal<F> {
void eat(F f);
}
class Dog<F> implements Animal<F> {
@Override
public void eat(F f) {
}
}
class Cat<F> implements Animal<F> {
@Override
public void eat(F f) {
}
}
//骨头
class Bone{}16.12_集合框架(泛型高级之通配符)
- A:泛型通配符
public class GenericDemo9 {
public static void main(String[] args) {
List<String> list1 = new ArrayList<String>();
List<Integer> list2 = new ArrayList<Integer>();
GenericUtils2.printList(list1);
GenericUtils2.printList(list2);
}
}
// 工具类，在这个类中提供一个打印的方法，可以将集合中所有元素打印出来
class GenericUtils2 {
// 打印集合中的元素
public static void printList(List<?> list) {
}
}//泛型通配符
// ? extends E
//? super E
public class GenericDemo10 {
public static void main(String[] args) {
// 创建一个Person对象
Person p = new Person();
// 创建一个装入Person对象的集合
List<Person> ps = new ArrayList<Person>();
// 将人装入到集合中
ps.add(p);
// 创建一个老师
Teacher t = new Teacher(); // 父类引用指向子类对象.
// 创建一个可以装入老师的集合
List<Teacher> ts = new ArrayList<Teacher>();
// 将老师装入到集合
ts.add(t);
// 正确的
// Utils<Person> u = new Utils<Person>();
// u.use(ps); // List<Person>
//
// Utils<Teacher> uu = new Utils<Teacher>();
// uu.use(ts);
// 错误的
//Utils<Person> u = new Utils<Person>();
//u.use(ts); // 错误原因:要求的是Person类型的 List<Person>而我传递的是 List<Teacher>
//想要不报错:只需要在use方法声明时不在写在use(List<T> list) 而是写成 use(List<? extends T> list)
Utils<Teacher> uu = new Utils<Teacher>();
uu.use(ps); //要求的是Teacher List<Teacher> 而我传递的是List<Person>
//想要不报错:只需要在use方法声明时不在写在use(List<T> list) 而是写成 use(List<? super T> list)
}
}
class Utils<T> {
public void use(List<? super T> list) {
System.out.println(list + "可以使用工具");
}
// 可不可以做到这样一种情况,
//例如1.如果传递的是t类型或t的父类型允许 2.如果传递的是t类型或t的子类类型也可以。
}
// 人类
class Person {
@Override
public String toString() {
return "人类";
}
}
// 老师类
class Teacher extends Person {
@Override
public String toString() {
return "老师";
}
}16.13_集合框架(增强for的概述和使用)
- A:增强for概述
- 简化数组和Collection集合的遍历//它的底层就是使用Iterator来实现的
- B:格式：
-
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
} - C:案例演示
- 数组，集合存储元素用增强for遍历
public static void arrayFor() {
int[] arr = { 1, 2, 3, 4 };
// 增强for
for (int n : arr) {
System.out.println(n);
}
}- D:好处
- 简化遍历//Iterable只有实现了这个接口的容器，才可以被forEach操作.
- 缺点:增强for不能做精确控制.
16.14_集合框架(ArrayList存储字符串和自定义对象并遍历增强for版)
A:案例演示
- ArrayList存储字符串并遍历增强for版
ArrayList<String> list = new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); list.add("d"); for(String s : list) { System.out.println(s); }
16.15_集合框架(三种迭代的能否删除)
- 普通for循环,可以删除,但是索引要(–减减)
- 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
- 增强for循环不能删除
16.16_集合框架(静态导入的概述和使用)
- A:静态导入概述
- B:格式：
- import static 包名….类名.方法名;
- 可以直接导入到方法的级别
- C:注意事项
- 方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。
16.17_集合框架(可变参数的概述和使用)
- A:可变参数概述
- 定义方法的时候不知道该定义多少个参数
- B:格式
- 修饰符 返回值类型 方法名(数据类型… 变量名){}
- C:注意事项：
- 这里的变量其实是一个数组
- 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个(在括号中最后一个)
16.18_集合框架(Arrays工具类的asList()方法的使用)
A:案例演示
Arrays工具类的asList()方法的使用
// 1.如果操作的是基本数据类型的数组，那么它是将数组做为了集合的元素。
//2.如果List集合是由数组转换过来，不可以使用集合中改变长度的方法.Collection中toArray(T[] a)泛型版的集合转数组
16.19_集合框架(集合嵌套之ArrayList嵌套ArrayList)
- A:案例演示
- 集合嵌套之ArrayList嵌套ArrayList
public class ListDemo2 {
public static void main(String[] args) {
// 1.创建一个可以装入一班学生的集合
List<Student> first = new ArrayList<Student>();
first.add(new Student("张三"));
first.add(new Student("李四"));
first.add(new Student("王五"));
// 2.创建一个可以装入二班学生的集合
List<Student> second = new ArrayList<Student>();
second.add(new Student("tom"));
second.add(new Student("fox"));
second.add(new Student("james"));
second.add(new Student("lucy"));
// 3.创建一个学校，用于装入一班与二班
// 问题:school这个集合的泛型是什么?
List<List<Student>> school = new ArrayList<List<Student>>(); // 描述的是school这个集合中的元素是List类型，而集合中元素List中的类型是String
school.add(first);
school.add(second);
//4.将集合中所有的元素遍历出来
//问题:对于List集合，你有几种遍历方式?
//1.Iterator 2.for+size+get 3.foreach 4.ListIterator
//关于这四种的选择 :1.如果要全部迭代出来 foreach 2.如果不涉及到同步问题 ,要精确控制 for+size+get 3.如果涉及到了同步 iterator
for(List<Student> ss:school){ //从school中迭代出来的是也是一个List集合
for(Student s:ss){ //双使用了一个foreach对其进行遍历。
System.out.println(s.getName());
}
System.out.println("------------------------");
}
}
}
class Student {
private String name;
public Student(String name) {
super();
this.name = name;
}
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
扫一扫
348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
