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(); //String中重写了equals()方法 //将每一个元素临时记录住 if(!newList.contains(temp)) { //如果新集合中不包含该元素 newList.add(temp); //将该元素添加到新集合中 } } return newList; //将新集合返回 }ps:
-
ArrayList的构造方法： ArrayList list= new ArrayList()构造一个初始容量为10的object类型的数组
-
遍历集合方法： 1，通过迭代器遍历集合 2，普通for循环(利用size(),get())遍历集合//这种遍历只支持list集合,set集合不可以,因为set集合无索引
-
public static void main(String[] args) { ArrayList list = new ArrayList();//构造一个初始容量为10的object类型的组 list.add(new Person("张三", 23)); list.add(new Person("李四", 24)); list.add(new Person("王五", 25)); list.add(new Person("赵六", 26)); Iterator it = list.iterator();//利用迭代器，遍历集合 while(it.hasNext()) { Person p = (Person)it.next(); System.out.println(p.getName() + "," + p.getAge()); } for(int i = 0; i < list.size(); i++) {//普通for循环：size()，get() Person p = (Person)list.get(i); System.out.println(p.getName() + "," + p.getAge()); } } }
16.02_集合框架(去除ArrayList中重复自定义对象元素)
- A:案例演示
- 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
- B:注意事项
- 自定义对象类中要重写equals()方法的
- contains和remove方法底层依赖与equals方法,如果没有重写equals方法,比较的是对象的地址值,重写之后比较的是对象的属性值
-
去除ArrayList中重复自定义对象元素的代码如同16.01，注意自定义对象类中要重写equals()方法
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);
-
LinkedList list = new LinkedList(); list.addFirst("a"); list.addFirst("b"); list.addFirst("c"); list.addFirst("d"); //在第一个位置添加 list.addLast("e"); //在末尾追加 System.out.println(list);//[d,c,b,a,e] Object obj1 = list.getFirst();//获取集合中的第一个元素 System.out.println(obj1);//d Object obj2 = list.getLast();//获取集合中的最后一个元素 System.out.println(obj2);//e //获取元素，集合中元素不会改变 System.out.println(list); Object obj3 = list.removeFirst();//删除集合中的第一个元素,并返回删除的元素 System.out.println(obj3);//d Object obj4 = list.removeLast();//删除集合中的最后一个元素 System.out.println(obj4); System.out.println(list); } ************************************** [d, c, b, a, e] d e [d, c, b, a, e] d e [c, b, a]
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()方法 } } -
//测试 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的新特性菱形泛型)
16.07_集合框架(ArrayList存储字符串和自定义对象并遍历泛型版)
- A:案例演示
- ArrayList存储字符串并遍历泛型版
ArrayList存储自定义对象并遍历泛型版：ArrayList<Person> list = new ArrayList<>(); //1.7版本出现,菱形泛型 //明确集合中存放元素的类型，添加时：只能添加该类型或该类型的子类型 list.add(new Person("张三", 23)); list.add(new Person("李四", 24)); list.add(new Person("王五", 25)); //有泛型集合的迭代： Iterator<Person> it = list.iterator(); while(it.hasNext()) { Person p = it.next(); /*省去了强转的麻烦，因为泛型的存在，集合中存取的指定类型的对象，那么获取对象时就是该类型的对象，所以不必强制转换了*/ System.out.println(p.getName() + "," + p.getAge()); } } ************************************** 张三,23 李四,24 王五,25ps: 1,泛型前面和后面的数据类型必须一致,或者可以省略后面(菱形泛型) * ArrayList<Object> list = new ArrayList<Person>();//这样是错的 2,泛型可以定义成Object,但是没有意义，
16.08_集合框架(泛型的由来)
- A:案例演示
- 泛型的由来:通过Object转型问题引入
- 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在类型转换异常(ClassCastException)，所以Java提供了泛型来解决这个安全问题。
ArrayList list2 = new ArrayList<>();//不添加泛型，即集合中可存取Object类型(任意类型)对象 list2.add("abc"); list2.add(123); list2.add(new Person("张三", 23));//此时list2集合中存放了String型，int型，和自定义引用类型的对象 Iterator it = list2.iterator(); while(it.hasNext()) {//遍历集合 Person p = (Person)it.next()；System.out.println(p.getName() + "," + p.getAge());}}/*(Person)it.next()强制类型转换，list2中有三种不同类型的对象，明显String型，int型是不能转化成自定义引用类型的。所以会造成类型转换异常。以至于，需要利用泛型明确集合中元素类型，防止出现类型转换异常*/ps:@SuppressWarnings({ "rawtypes", "unchecked" }) //去除黄色提示,
16.09_集合框架(泛型类的概述及使用)
- A:泛型类概述
- 把泛型定义在类上,创建该类对象时，为泛型赋值。
- 好处：把运行时的错误，提前到编译期间。
- B:定义格式
- public class 类名<泛型类型1,…>
- C:注意事项
- 泛型类型必须是引用类型
- D:案例演示
- 泛型类的使用
16.10_集合框架(泛型方法的概述和使用)
- A:泛型方法概述
- 把泛型定义在方法上
- B:定义格式
- public <泛型类型> 返回类型 方法名(泛型类型 变量名)
- C:案例演示
- 泛型方法的使用
public class Tool<W> {//泛型类，创建Tool对象的时候给W传值(W是个变量，接收引用类型)。 private W e; public W getObj() { return e; } public void setObj(W e) {//Ojbect obj = new Student(); this.e = e; } public void show(W w) {//泛型方法 System.out.println(w);//非静态方法由对象来调用，在创建Tool对象时给W赋值了，当调用show(W w)时W是有值得 } public static<T> void print(T t) { //静态方法的泛型不能和普通方法泛型一样 System.out.println(t);//静态方法是随着类的加载而加载的。而在类加载时还没创建对象 }//静态方法拥有自己的泛型，在调用静态方法时为泛型赋值。 }//NO.1 Tool<Student> t = new Tool<Student>();/*创建Tool对象时，指明泛型为：自定义类型Student，所以上面代码中的W都换成了Student*/ t.setObj(new Student("张三", 23)); Student s = t.getObj(); System.out.println(s);//NO.2 Tool<String> t = new Tool<>();
t.show("abc");/*创建Tool对象时，指明泛型为：String类型，所以上面代码中的W都换成了String*/
Tool.print("abc");//调用上面代码中的静态方法，调用时指明泛型，（因传入的是字符串）所以T为String
16.11_集合框架(泛型接口的概述和使用)
- A:泛型接口概述
- 把泛型定义在接口上
- B:定义格式
- public interface 接口名<泛型类型>
- C:案例演示
- 泛型接口的使用
-
interface Inter<T> {//定义泛型接口，在实现时可指定泛型类型 public void show(T t); } public class Demo implements Inter<String>{//开发推荐用第一种,实现接口的时候,你已经可以明确具体是什么类型了 @Override public void show(String t) { System.out.println(t); } }
16.12_集合框架(泛型高级之通配符)
- A:泛型通配符<?>
- 任意类型，如果没有明确，那么就是Object以及任意的Java类了
- eg:ArrayList<?> list1 = new ArrayList<>();
- 不确定后面返回什么类型的泛型时使用
- B:? extends E
- 向下限定，E及其子类（？是子类E是父类）可以添加E类型以及E的子类型,E是上边界(固定上边界)
- C:? super E
- 向上限定，E及其父类（E是子类？是父类）
ArrayList<Person> list1 = new ArrayList<>();
list1.add(new Person("张三", 23));
list1.add(new Person("李四", 24));
list1.add(new Person("王五", 25));
ArrayList<Student> list2 = new ArrayList<>();
list2.add(new Student("马哥", 18));
list2.add(new Student("马哥粉丝团团长", 20));
list2.add(new Student("马哥粉丝团秘书", 16));
list1.addAll(list2);//将一个集合添加到另一个类中
/*
* list1存放的是Person类型对象，list2存放的是Student类型对象。
*因list1中对象和list2集合对象存在? extends E关系(Student继承于Person)，才能将list2中元素添加到list1中
*/
System.out.println(list1); ************************************** [Person [name=张三, age=23], Person [name=李四, age=24], Person [name=王五, age=25], Person [name=马哥, age=18], Person [name=马哥粉丝团团长, age=20], Person [name=马哥粉丝团秘书, age=16]]
ArrayList<Person> list1 = new ArrayList<>();
list1.add(new Person("张三", 23));
list1.add(new Person("李四", 24));
list1.add(new Person("王五", 25));
ArrayList<Student> list2 = new ArrayList<>();
list2.add(new Student("马哥", 18));
list2.add(new Student("马哥粉丝团团长", 20));
list2.add(new Student("马哥粉丝团秘书", 16));
list1.addAll(list2);//将一个集合添加到另一个类中
/*
* list1存放的是Person类型对象，list2存放的是Student类型对象。
*因list1中对象和list2集合对象存在? extends E关系(Student继承于Person)，才能将list2中元素添加到list1中
*/
System.out.println(list1); ************************************** [Person [name=张三, age=23], Person [name=李四, age=24], Person [name=王五, age=25], Person [name=马哥, age=18], Person [name=马哥粉丝团团长, age=20], Person [name=马哥粉丝团秘书, age=16]] 16.13_集合框架(增强for的概述和使用)
- A:增强for概述
- 简化数组和Collection集合的遍历
- 快捷生成foreach：先写：fore 再按：alt+/
- B:格式：
-
for(元素数据类型 变量 : 数组或者Collection集合) { 使用变量即可，该变量就是元素 } - C:案例演示
- 数组，集合存储元素用增强for遍历
- D:好处
- 简化遍历
-
ArrayList<String> list = new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); list.add("d"); for (String string : list) {//遍历集合 System.out.println(string); } int[] arr = {11,22,33,44,55}; for (int i : arr) {//遍历数组 System.out.println(i); } } ********************************** a b c d 11 22 33 44 55
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) { //临时变量的数据类型和泛型一致,如果没有泛型默认Object System.out.println(s); }
16.15_集合框架(三种迭代的能否删除)
- 普通for循环,可以删除,但是索引要--
- 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
- 增强for循环不能删除
16.16_集合框架(静态导入的概述和使用)
- A:静态导入概述
- B:格式：
- import static 包名….类名.方法名;
- 可以直接导入到方法的级别
- C:注意事项
- 方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。
import static java.util.Arrays.sort;//静态导入方法 import static java.util.Arrays.toString; public class Demo08_StaticImport { /** * @param args * Jdk1.5的新特性 * 1,自动拆装箱 * 2,泛型 * 3,增强for循环 * 4,静态导入:其实导入的是静态的方法,只要是静态的方法都可以用静态导入(开发严重不推荐) */ public static void main(String[] args) { int[] arr = {55,44,33,22,11};//Arrays类 sort(arr);//排序，直接用方法 //System.out.println(toString(arr)); //数组转换成字符串并打印,和其他toString方法冲突 } }
16.17_集合框架(可变参数的概述和使用)
- A:可变参数概述
- 定义方法的时候不知道该定义多少个参数
- B:格式
- 修饰符 返回值类型 方法名(数据类型… 变量名){}
- C:注意事项：
- 这里的变量其实是一个数组
- 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
-
public static void print(int x,int ... arr) {//可变参数要在最后 for (int i : arr) {//int ... arr = int[] arr System.out.println(i); } } -
public static void demo1() { int[] arr = {11,22,33,44,55}; print(arr); print(11,22,33,44,55);//可以调用含可变参数的方法 } /*public static void print(int[] arr) {//不带可变参数 for (int i : arr) { System.out.println(i); } }*/ //带可变参数和不带可变参数的方法不可以同时存在 public static void print(int ... arr) { //可变参数,其实就是一个可以变化的数组 for (int i : arr) {//int ... arr = int[] arr System.out.println(i); } } }
16.18_集合框架(Arrays工具类的asList()方法的使用)
- A:案例演示
- Arrays工具类的asList()方法//把数组转换成集合
- Collection中toArray(T[] a)泛型版的集合转数组
int[] arr = {11,22,33,44,55}; List<int[]> list = Arrays.asList(arr); /*基本数据类型数组转集合：把数组当做一个对象，存在集合中，所以泛型：int[]*/ System.out.println(list); Integer[] arr2 = {11,22,33,44,55}; //11,22,33,44,55是Integer类型,自动装箱 List<Integer> list2 = Arrays.asList(arr2); //把数组转换成集合,必须是引用数据类型的数组,否则会将整个数组当作一个对象 System.out.println(list2); ************************************* [[I@15db9742] [11, 22, 33, 44, 55]
ps:数组转换成集合不能改变长度(add()方法，remove()不可用),但是可以应用集合中其他的方法
16.19_集合框架(集合嵌套之ArrayList嵌套ArrayList)
- A:案例演示
- 集合嵌套之ArrayList嵌套ArrayList
-
// 集合嵌套集合，类似于数组的嵌套 ArrayList<ArrayList<Student>> list = new ArrayList<>(); //集合中添加集合：把整个集合当做泛型 //第一个班级 ArrayList<Student> first = new ArrayList<>(); first.add(new Student("马哥", 18)); first.add(new Student("马哥第一批粉丝团1", 88)); first.add(new Student("马哥第一批粉丝团2", 20)); //第二个班级 ArrayList<Student> second = new ArrayList<>(); second.add(new Student("马哥第二批粉丝团1", 5)); second.add(new Student("马哥第二批粉丝团2", 100)); //将第一个班级和第二个班级添加到list里 list.add(first); list.add(second); for(ArrayList<Student> li : list) { for(Student s : li) { System.out.print(s + " "); } System.out.println(); } } ***************************************** Person [name=马哥, age=18] Person [name=马哥第一批粉丝团1, age=88] Person [name=马哥第一批粉丝团2, age=20] Person [name=马哥第二批粉丝团1, age=5] Person [name=马哥第二批粉丝团2, age=100]
编程练习：
对集合中添加的元素排序
ArrayList<String> list1 = new ArrayList<>();
list1.add("b");
list1.add("f");
list1.add("e");
list1.add("c");
list1.add("a");
list1.add("d");
sort(list1);
System.out.println(list1); // a, b, c, d, e, f
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(5);
list2.add(8);
list2.add(3);
list2.add(1);
list2.add(4);
sort(list2);
System.out.println(list2); //1,3,4,5,8
}
//public static <T> void sort(ArrayList<T> list)
/*T不确定是什么类型，不一定都有compareTo()方法，所以会报错
*compareTo()方法必须是Comparable的子类才具备。
*所以要保证T是Comparable的子类，即<T extends Comparable<T>>
*///无论是继承接口还是继承类都是extends
public static <T extends Comparable<T>> void sort(ArrayList<T> list)
{
T m;
for(int i=0;i<list.size();i++)
{
for(int j=i+1;j<list.size();j++)
{
if(list.get(i).compareTo(list.get(j)) > 0)
{
m=list.get(i);
list.set(i, list.get(j));
list.set(j, m);
}
}
}
}
********************************************
[a, b, c, d, e, f]
[1, 3, 4, 5, 8]16.20_day16总结
- 把今天的知识点总结一遍。
扫一扫
1233
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
