14_集合框架

最新推荐文章于 2021-07-09 23:14:38 发布
最新推荐文章于 2021-07-09 23:14:38 发布
阅读量229 收藏 1
点赞数 1
分类专栏： Java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45044194/article/details/97942295
版权

百知教育 - 孙帅 - 14_集合框架

01_集合的概念

  • 集合：
    是一种工具类，是对象的容器，可以用于存储数量不等的多个对象的对象，代替数组
  • 所有集合的接口和相关实现类都在java.util包中
  • 底层结构：
    数组
  • 代码：
    package day15;
import java.util.Arrays;
public class TestMyList{
 public static void main(String[] args){
  MyList list = new MyList();
  list.add("ABC");
  list.add("XYZ");
  list.add("123");
  list.add("AAA");
  
  System.out.println(list.get(0));
  
  for(int i = 0; i < list.size(); i++){
   System.out.println(list.get(i));
  }
 }
}
class MyList{
 private Object[] os = new Object[10];
 private int index;  //记录数组中真正存储了几个元素
 
 public void add(Object o){
  if(index == os.length){
   os = Arrays.copyOf(os, os.length*2);
  }
  os[index] = o;
  index++;
 }
 
 public void add(int pos, Object o){
  //xxxxxxxx
 }
 public int size(){
  return index;
 }
 public Object get(int i){
  return os[i];
 }
}
  • 运行结果：
    在这里插入图片描述

02_Collection

  • 概念：
    Collection接口是List接口和Set接口的 父接口
  • 特点：
    元素是Object
  • 常用方法：
    1. add(Object) 把元素添加到集合中
    2. addAll(Collection c) 把c集合中的所有元素添加到集合中
    3. clear() 清空集合
    4. contains(Object o) 判断o元素在集合中是否存在
    5. remove(Object o) 从集合中删除元素o
    6. size() 返回集合的长度
    7. toArray() 将集合转化为数组
    8. isEmpty() 判断集合是否为空
  • List特点
    • 元素按顺序存储（下标）
    • 元素 可以重复
  • Set特点
    • 元素无顺序
    • 元素内容 不可重复

03_List常用方法

  • add(int pos, Object o) 将元素插入到指定位置

  • remove(int pos) 删除指定位置的元素

  • get(int pos) 获得指定位置的元素

  • indexOf(Object o) 获得o元素的首下标

  • lastIndexOf(Object o) 获得o元素的尾下标

  • set(int pos, Object o) 将o元素设置到pos位置，覆盖原有的元素

  • subList(int start, int end) 获得某段位置的子集合(包含start，不包含end)

  • 代码：
    package day15;
import java.util.*;
public class TestList{
 public static void main(String[] args){
  List list = new ArrayList();
  list.add("YKY");
  list.add("LYH");
  list.add("HHH");
  list.add("ZYK");
  list.add("YXM");
  list.add("WKY");
  list.add("YKY");
  System.out.println(list.size());
  System.out.println(list.indexOf("YKY"));
  System.out.println(list.lastIndexOf("YKY"));
  list.remove(0);
  System.out.println(list.get(0));
 }
 
 static Object[] findAllDogs(Object[] as){
  List list = new ArrayList();
  for(int i = 0; i < list.size(); i++){
   if(as[i] instanceof Dog){
    list.add(as[i]);
   }
  }
  return list.toArray();
 }
}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
  • 运行结果：

    在这里插入图片描述

04_List的遍历

  • 遍历
    1. 下标遍历
    2. 迭代器遍历
  • 代码
    package day15;
import java.util.*;
public class TestIterator{
 public static void main(String[] args){
  List list = new ArrayList();
  list.add("YKY");
  list.add("LYH");
  list.add("HHH");
  list.add("ZYK");
  list.add("YXM");
  list.add("WKY");
  list.add("YKY");
  
  print1(list);
  System.out.println();
  print2(list);
 }
 static void print1(List list){
  for(int i = 0; i < list.size(); i++){
   Object o = list.get(i);
   String s = (String)o;
   if("ZYK".equals(s)){
    list.remove(i);
    continue;
   }
   System.out.println(s.toUpperCase());
  }
 }
 static void print2(Collection con){
  Iterator it = con.iterator();  
  while(it.hasNext()){
   String s = (String)it.next();
   if("ZYK".equals(s)){
    it.remove();
   }
   System.out.println(s.toUpperCase());
  }
 }
}
  • 运行结果：
    在这里插入图片描述

05_在JDK5中的集合遍历

  • for-each遍历特点：
    遍历时不能对原集合进行更改
  • for-each遍历代码：
    static void print3(Collection con){
	for(Object o : con){
		String s = (String)o;
		System.out.println(s.toUpperCase());
	}
}

06_JDK8中的集合遍历

  • forEach()方法特点：
    需要实现 java.util.function.Consumer接口
  • forEach()遍历代码：
    package day15;
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;
public class TestConsumerAccept{
 public static void main(String[] args){
  List list = new ArrayList();
  list.add("YKY");
  list.add("LYH");
  list.add("HHH");
  list.add("ZYK");
  list.add("YXM");
  list.add("WKY");
  list.add("YKY");
  
  print4(list);
  System.out.println();
  print5(list);
 }
 static void print4(Collection con){
  con.forEach(new Consumer(){
   public void accept(Object o){
    String s = (String)o;
    System.out.println(s.toUpperCase());
   }
  });
 }
 /*  from Collection
 public void forEach(Consumer c){
  Iterator it = this.iterator();
  while(it.hasNext()){
   Object o = it.next();
   c.accept(o);
  }
 }
 */
 static void print5(Collection con){
  con.forEach(System.out::println);  
 }
}
  • 运行结果：
    在这里插入图片描述

07_List的实现类

  • ArrayList特点：
    数组实现、查询快、增删慢、线程不安全、并发效率高、JDK1.2推出
  • Vector特点：
    数组实现、查询快、增删慢、线程安全、并发效率低、JDK1.0推出
  • LinkedList特点：
    链表实现、查询慢、增删快
  • ArrayList代码：
    package day15;
import java.util.LinkedList;
public class TestLinkedList{
 public static void main(String[] args){
  LinkedList list = new LinkedList();
  list.add("YKY");
  list.add("LYH");
  list.add("HHH");
  list.add("YXM");
  list.add("ZYK");
  list.addFirst("WKY");
  list.removeLast();
  
  for(Object o : list){
   System.out.println(o);
  }
 }
}
  • 运行结果：
    在这里插入图片描述

08_集合中的泛型 < E >

  • 泛型技术来源：
    JDK5
  • 作用：
    约束 集合 中 元素的类型
  • 代码：
    package day16;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
import java.util.function.Consumer;
public class TestGenerics1{
 public static void main(String[] args){
  List<String> list = new ArrayList<String>();
  list.add("YKY");
  list.add("LYH");
  list.add("HHH");
  list.add("YXM");
  list.add("ZYK");
  
  for(int i = 0; i < list.size(); i++){
   String s = list.get(i);
   System.out.println(s.toUpperCase());
  }
  System.out.println();
  
  Iterator<String> it = list.iterator();
  while(it.hasNext()){
   String s = it.next();
   System.out.println(s.toUpperCase());
  }
  System.out.println();
  
  for(String s : list){
   System.out.println(s.toUpperCase());
  }
  System.out.println();
  
  list.forEach(new Consumer<String>(){
   public void accept(String s){
    System.out.println(s.toUpperCase());
   }
  });
  System.out.println();
  
  list.forEach(System.out::println);
 }
}
  • 运行结果：
    在这里插入图片描述

09_泛型的多态

  • 泛型的特点
    • 只在编译时有泛型，运行时没泛型
    • 泛型没有多态，赋值语句前后泛型必须保持一致
  • 语法（JDK7）：
    List list = new ArrayList<>();
  • 代码：
    package day16;
import java.util.List;
import java.util.ArrayList;
public class TestGenerics2{
 public static void main(String[] args){
  //List<Animal> list1 = new ArrayList<Animal>();
  List<Animal> list1 = new ArrayList<>();
  //List<Dog> list2 = new ArrayList<Dog>();
  List<Dog> list2 = new ArrayList<>();
  
  System.out.println(list1.getClass() == list2.getClass());
  
  //list1.add(new Cat());
 }
}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
  • 运行结果：
    在这里插入图片描述

10_泛型的通配符

  • 方法参数的泛型定义：
    通配符 <？>
  • 用法：
    • <？> ： 任何类型
    • <？ extends A> ： A或A的任何子类(A可以是类也可以是接口)
    • <？ super A> ： A或A的父类
  • 代码(编译通过)：
    package day16;
import java.util.ArrayList;
import java.util.List;
public class TestGenerics3{
 public static void main(String[] args){
  List<Object> l1 = new ArrayList<>();
  List<String> l2 = new ArrayList<>();  //implements Comparable
  List<Number> l3 = new ArrayList<>();
  List<Integer> l4 = new ArrayList<>();  //extends Number implements Comparable
  List<Double> l5 = new ArrayList<>();  //extends Number implements Comparable
  List<Comparable> l6 = new ArrayList<>();  
  print(l1);
  //print(l2);
  print(l3);
  //print(l4);
  //print(l5);
  //print(l6);
 }
 /*和下面的方法不能同时出现，只有泛型不同的两个方法不算重载，因为运行时没有泛型。
 static void print(List<? extends Number> list){
  for(int i = 0; i < list.size(); i++){
   Number n = list.get(i);
  }
 }
 */
 static void print(List<? super Number> list){
  for(int i = 0; i < list.size(); i++){
   Object o = list.get(i);
  }
 }
}

11_泛型方法

  • < T >使用方法
    • T可以替换为任何标识符，通常写一个大写字母
    • 泛型定义在修饰符之后，返回值类型之前
    • < T extends A >: T为A或A的子类
    • < T extends A & B >: T为A或A的子类，同时实现B接口
    • 其他用法：
      • static <T, s> void m(T t, S s){}
      • static <T, S extends T> void m2(T t, S s){}
  • 代码1(编译通过)：
    package day16;
import java.util.ArrayList;
import java.util.List;
public class TestGenerics4{
 public static void main(String[] args){
  List<Object> l1 = new ArrayList<>();
  List<String> l2 = new ArrayList<>();  //implements Comparable
  List<Number> l3 = new ArrayList<>();
  List<Integer> l4 = new ArrayList<>();  //extends Number implements Comparable
  List<Double> l5 = new ArrayList<>();  //extends Number implements Comparable
  List<Comparable> l6 = new ArrayList<>();  
  
  //copy(new Object[]{}, l1);
  //copy(new String[]{}, l2);
  //copy(new Number[]{}, l3);
  copy(new Integer[]{}, l4);
  copy(new Double[]{}, l5);
  //copy(new Comparable[]{}, l6);
 }
 
 static <T extends Number & Comparable> void copy(T[] os, List<T> list){
  for(T o : os){
   list.add(o);
  }
 }
}
  • 代码2：
    package day16;
import java.util.ArrayList;
import java.util.List;
public class TestGetAllDogs{
 public static void main(String[] args){
  
 }
 static Dog[] findAllDogs(Animal[] as){
  List<Dog> result = new ArrayList<>();
  for(Animal a : as){
   if(a instanceof Dog){
    Dog d = (Dog)a;
    result.add(d);
   }
  }
  //result --> Dog[]
  return result.toArray(new Dog[]{});
 }
}

12_泛型类

  • 代码(编译通过)：
    package day16;
public class TestGenerics5{
 public static void main(String[] args){
  MyClass<String> m1 = new MyClass<>();
  
  MyClass<Integer> m2 = new MyClass<>();
  
 }
}
class MyClass <T>{
 public void method1(T t){}
 public T method2(){
  return null;
 }
}
/*
class MyArrayList <T>{
 private T[] os;
 private int index;
 public void add(T t){
 }
 public T get(int pos){
  return os[pos];
 }
}
MyArrayList<String> m1 = new MyArrayList<>();
m1.add("abc");
String s = m1.get(0);
*/
interface A{
 void m(String s);
}
interface B{
 void m(Integer i);
}
interface I<T>{
 void m(T t);
}
interface N<T>{
 T m();
}
class c1 implements I<String>{
 public void m(String s){}
}
class c2 implements I<Integer>{
 public void m(Integer i){}
}
class c3 implements N<String>{
 public String m(){
  return "helloword"; 
 }
}
class c4 implements N<Integer>{
 public Integer m(){
  return 0;
 }
}
cherishIntention
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 集合框架 详解
qq_37552636的博客
01-21 905
一、Java 集合框架概述 集合框架是一个用来代表和操纵集合的统一架构（java集合框架位于java.util包中）。所有的集合框架都包含如下内容： 接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。 算法：是实现集合接口的对象里的.
java集合框架PPT
05-23
Java集合框架是Java编程语言中一个至关重要的部分，它为数据存储和操作提供了丰富的类库。这个PPT作为培训教材，旨在深入解析Java集合框架的核心概念、接口和类，帮助学习者掌握其基本使用和高级特性。以下是Java...
14_集合框架(续)
m0_45044194的博客
08-02 212
百知教育 - 孙帅 - 14_集合框架(续) 13_List的排序 代码： 在这里插入代码片
17_IO 编程
m0_45044194的博客
08-08 198
百知教育 - 孙帅 - 17_IO 编程 01_IO流的概念和分类 流 流就是内存与存储设备之间 传输数据 的通道、管道。 IO流的分类 按方向（以JVM虚拟机为参照物）【重点】 输入流： 将<存储设备>中的内容 读入 到<内存>中。 输出流： 将<内存>中的内容 写入 到<存储设备>中。 按单位 字节流： 以字节为单位，可以操作 所...
20_Lambda表达式与Stream编程
m0_45044194的博客
08-20 201
百知教育 - 孙帅 - 20_Lambda表达式与Stream编程 01_Java8中的接口 接口的新语法： 接口和工具类 Collection和Collections Executor和Executors 接口的静态方法 Comparator接口 接口的默认方法 接口版本的向后兼容 代码： package day26; import java.util.Comparato...
❤有学妹问我Java架构师怎么入门，我甩出12k亲身体验的学习视频推荐给她
热门推荐
XiaoLin
07-09 1万+
序言 又到了一年一度的高考选专业的日子，我大学的专业是计算机科学与技术，很多的粉丝或者亲朋好友会问我：你这个专业怎么样呀，怎么入门呀，我的回答一般都是B站自学，这个也确实是，因为在大学老师教的东西很多都是过时的东西了，基本上企业里面也很少用到，我大学期间都是自己一个人在B站上自学的，也积累了很多的经验，知道哪些课程好，哪些课程适合小白，下面我会给出自己觉得还不错的课程，一个是二选一（全程无任何恰饭），顺序就是整个学习计划，包括了基础、进阶、项目、前端、运维等知识，喜欢的小伙伴可以给个一键三连！ IDEA使用
11_内部类
m0_45044194的博客
07-28 146
百知教育 - 孙帅 - 11_内部类 01_内部类概述 概念： 在一个类的内部再定义一个完整类 特点（编译时类型：运行时，用到哪个类就加载哪个类，不分内外）： 编译之后分别生成独立的字节码文件。 内部类可直接访问外部类的私有成员，而不破坏封装。 可为外部类提供必要的内部功能组件。 分类： 成员内部类、静态内部类、局部内部类、匿名内部类 代码（编译通过）： package day13...
集合框架体系概述
weixin_43034627的博客
08-27 1879
Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。...
【14】集合1_集合框架，迭代器，List集合，Set集合
努力后才会有收获....加油！
07-17 1274
7.1集合框架   为什么出现集合类？ 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。   数组和集合类同是容器，有何不同？ 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。   集合类的特点 集合只用于存储对象，集合长度是可变的，集合可以存储不同
Java集合框架
12-22
Java集合框架是Java编程语言中一个至关重要的组件，它为开发者提供了存储和管理对象的统一方式。集合可以被看作是一个容器，允许我们存放多个对象，并支持常见的操作，如添加、删除和修改元素。 Collection接口是...
Serial Communication 14.rar_labview Actor_labview框架_poetry13j_操作
07-15
在给定的“Serial Communication 14.rar”压缩文件中，我们可以推测它包含了一个关于LabVIEW中串行通信的实例，特别是与Actor框架和Poetry13j相关的应用。 1. **Serial Communication**：串行通信是设备间进行数据...
java集合框架
06-21
在黑马程序员_毕向东_Java基础视频教程第14天-11-集合框架(ArrayList练习2).avi中，可能会详细讲解ArrayList的用法，包括如何创建ArrayList实例、向ArrayList中添加元素、删除元素、遍历ArrayList以及如何处理...
[传智播客]Java基础视频教程之集合框架1【14节课】.txt
07-17
该视频课件包括java基础集合框架之迭代器、List集合、ListIterator、Vector、ArrayList、LinkedList及HashSet等，详细课程内容如下>>
chapter 01习题
m0_45044194的博客
05-20 1717
百知教育学习 - 胡鑫喆 - chapter 01习题 1. （标识符命名）下面几个变量中，哪些是对的？哪些是错的？错的请说明理由 A.ILoveJava B.$20 C.learn@java D.antony.lee E.Hello_World F.2tigers 代码/* * A right * B right * C wrong --> @ 不能出...
chapter 03函数习题
m0_45044194的博客
05-20 423
百知教育学习 - 胡鑫喆 - chapter 03函数习题 题目链接 提取码：nxo0 1.代码 package chapter_03; import java.util.*; public class Practice_03_01{ public static void main(String[] args) { Scanner s = new Scanner(System.in); ...
chapter 02循环结构习题
m0_45044194的博客
05-20 410
百知教育学习 - 胡鑫喆 - chapter 02循环结构习题 题目链接 提取码：a53a 1.代码 package chapter_02; public class Practice_02_01{ public static void main(String[] args) { int sum = 0; for(int i = 1; i < 101; i++) { su...
chapter 04 数组
m0_45044194的博客
06-05 290
百知教育学习 - 胡鑫喆 - chapter 04 数组 题目链接 提取码：h008 1、代码 package chapter_04; public class Practice_04_01{ public static void main(String[] args) { /* A 正确 * B 正确 * C 错误 --> int[] a = {1,2,3,4,5};...
循环与分支结构
m0_45044194的博客
05-19 277
百知教育学习 - 胡鑫喆 - 循环与分支结构 一、if选择结构与分支结构 if 语法 if（布尔表达式） { 代码块 } 在java中if的条件中只能写布尔表达 式，不能写整数表达式。 代码package day3; import java.util.Scanner; public class TestIf{ public static void main(String[] args){ ...
16_多线程（续）
m0_45044194的博客
08-07 253
百知教育 - 孙帅 - 16_多线程（续） 14_深入比较ArrayList和Vector Collections工具类中提供了多个可以获得线程安全集合的方法(均以synchronized实现)： public static < T > Collection synchronizedCollection(Collection c) public static < T &g...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值