Collection接口之List、泛型

Collection接口

  • List、Queue、Set的父接口
  • 定义了可用于操作List、Set、Queue的方法——增删改查

List接口及其实现类:ArrayList

  • List是元素有序且可重复的集合、被称为序列
  • List可以精确的控制每个元素的插入位置、或删除指定位置的元素
  • ArrayList——数组序列,是List接口的重要实现类
  • ArrayList底层由数组实现

List的增加和遍历方法:

 1 import java.util.*;
 2 class ListDemo3
 3 {
 4     public static void main(String[] args)
 5     {
 6         List list = new ArrayList();
 7         add(list);
 8         //select(list,0);
 9         testIterator(list);
10     }
11     //添加
12     public static void add(List list)
13     {
14         course c1 = new course("1","离散数学");
15         course c2 = new course("2","JDBC");
16         course [] c3 = {new course("3","C语言"),new course("4","高等数学")};
17
18         list.add(c1);
19         list.add(0,c2);//添加到指定位置
20         //addAll要接收一个Collction的具体实例,通过Arrays的asList方法将course数组转为List
21         list.addAll(Arrays.asList(c3));//添加数组
22         list.addAll(0,Arrays.asList(c3));//添加到指定位置(list中的元素是可重复的)
23
24     }
25
26     //查找
27     public static void select(List list,int a)
28     {
29         System.out.println("通过get方法访问:");
30         //一个对象被添加到集合中去时会将其转为Object类型存储到集合中
31         //所以需要将其强转。
32         System.out.println(((course)list.get(a)).name);
33         //通过for循环遍历list中的元素
34         int size = list.size();
35         for(int i=0; i<size; i++)
36         {
37             course c = (course)list.get(i);
38             System.out.println(c.id+"..."+c.name);
39         }
40     }
41     //通过迭代器访问
42     //collection接口中定义了一个Iterator方法,可以返回一个当前
43     //集合对象的迭代器,然后通过迭代器去遍历当前集合中的每一个元素
44     //迭代器是用来遍历集合中元素的,本身不具备任何存储元素的功能
45     //(迭代器依赖与集合存在本身不能独立存在)
46     public static void testIterator(List list)
47     {
48         Iterator it = list.iterator();
49         System.out.println("通过迭代器遍历List:");
50         //Iterator是一个接口,其hasNext方法若还有元素则返回真
51         while (it.hasNext())
52         {
53             //Iterator的next方法返回迭代的下一个元素
54             course c = (course)it.next();
55             System.out.println(c.id+"...."+c.name);
56         }
57     }
58     //通过foreach迭代集合
59     public static void testForEach(List list)
60     {
61         for (Object obj : list)
62         {
63             course c = (course)obj;
64             System.out.println(c.id+"..."+c.name);
65         }
66     }
67 }
68
69 //课程类
70 class course
71 {
72     String id;
73     String name;
74     course(String id, String name)
75     {
76         this.id = id;
77         this.name = name;
78     }
79 }

ListDemo

List的修改和删除方法:

 1 import java.util.*;
 2 class ListDemo4
 3 {
 4     public static void main(String[] args)
 5     {
 6         List list = new ArrayList();
 7         add(list);
 8         change(list);
 9         testForeach(list);
10         testRemove(list,1);
11         testForeach(list);
12     }
13
14     public static void add(List list)
15     {
16         course [] arr =
17             {new course("1","JDBC"),new course("2","MySQL"),new course("3","大神")};
18         list.addAll(Arrays.asList(arr));
19     }
20     //List集合修改的方法
21     public static void change(List list)
22     {
23         list.set(1,new course("3","首席技术官"));
24     }
25     //通过for each遍历集合
26     public static void testForeach(List list)
27     {
28         for(Object obj : list)
29         {
30             course c = (course)obj;
31             System.out.println(c.id+"..."+c.name);
32         }
33     }
34     //List删除的方法
35     public static void testRemove(List list,int id)
36     {
37         //删除单个
38         list.remove(id);
39         System.out.println("删除了课程");
40         //删除单个
41         course c1 = (course)list.get(0);
42         list.remove(c1);
43         //删除多个
44         course [] c = {list.get(0),list.get(1)};
45         list.removeAll(Arrays.asList(c));
46     }
47
48 }
49 //课程类
50 class course
51 {
52     String id;
53     String name;
54     course(String id, String name)
55     {
56         this.id = id;
57         this.name = name;
58     }
59 }

ListDemo

泛型:

  • 集合中的元素,可以是任意类型的对象(对象的引用)如果把某个对象放入集合,则会忽略它的类型。而把他当做Object处理
  • 泛型则是规定了某个集合只可以存放特定类型的对象。会在编译期间进行类型检查,可以直接按指定类型获取集合元素
  • 泛型集合中不能添加泛型规定的类型及其子类型以外的对象。
  • 泛型集合可以添加泛型的子类型的对象实例
  • 泛型集合中的规定类型不能使用基本数据类型,但可以使用包装类

 1 import java.util.*;
 2 class GenericDemo
 3 {
 4     public static void main(String[] args)
 5     {
 6         //generic();
 7         generic_1();
 8     }
 9     public static void generic()
10     {
11         List<courses> list = new ArrayList<courses>();
12         courses [] arr = {new courses("1","首席技术官"),
13             new courses("2","首席架构师"),new courses("3","项目经理"),new courses("4","独当一面")};
14
15         list.addAll(Arrays.asList(arr));
16         //泛型能添加泛型规定类型的子类型。
17         childCourses cc = new childCourses();
18         cc.id="1";
19         cc.name="时代的终结者";
20         list.add(cc);
21         //因为规定了泛型所以可以直接取出来而不用担心类型。
22         //list.add("adfas");无法添加泛型规定以外的对象
23         for (courses c : list)
24         {
25             System.out.println(c.id+":"+c.name);
26         }
27     }
28     //基本类型必须使用包装类使用泛型
29     public static void generic_1()
30     {
31         List<Integer> list = new ArrayList<Integer>();
32
33         list.add(1);
34         System.out.println("基本类型必须使用包装类作为泛型:"+list.get(0));
35     }
36
37 }
38 class courses
39 {
40     String name;
41     String id;
42     courses(String name, String id)
43     {
44         this.name = name;
45         this.id = id;
46     }
47     courses()
48     {
49     }
50 }
51 class childCourses extends courses
52 {
53
54 }

GenericDemo

时间: 11-02

Collection接口之List、泛型的相关文章

Java中Collection接口的用法

Collection接口是List.Set.Queue接口的父接口Collection接口定义了可用于操作List.Set和Queue的方法--增删改查List接口及其实现类--ArrayListList是元素有序并且可以重复的集合,被称为序列.List可以精确的控制每个元素的插入位置,或删除某个位置元素List有add()插入方法和get()获取方法ArrayList--数组序列,是List的一个重要实现类ArrayList底层是由数组实现的,这也是其名字的由来 List接口 List中的元素

java.util (Collection接口和Map接口)

1:Collection和Map接口的几个主要继承和实现类                  1.1  Collection接口 Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements).一些Collection允许相同的元素而另一些不行.一些能排序而另一些不行.Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的"子接口"如List和Set. 如

Java Collection Framework : Collection 接口

一.要点 Collection 接口 Collection 接口的默认实现:AbstractCollection Optional operations(可选方法) 二.Collection 接口 1.JDK 对 Collection 接口的描述 Collection 接口是 Collection 层次结构中的根接口.Collection 表示一组对象,这些对象也称为 collection 的元素.一些 collection(List,Queue) 允许有重复的元素,而另一些(Set)则不允许.

疯狂Java学习笔记(34)----------Iterator、Collection接口以及foreach

Iterator.Collection接口: 如下图:Iterator.Collection同在一个包中: 红字部分使我们经常遇到的,但是遇到又不知道怎么去理解,去应用它! Collection是最基本集合接口,它定义了一组允许重复的对象.Collection接口派生了两个子接口Set和List,分别定义了两种不同的存储方式,如下: 2. Set接口 Set接口继承于Collection接口,它没有提供额外的方法,但实现了Set接口的集合类中的元素是无序且不可重复. 特征:无序且不可重复. 3.

23、Collection接口和List集合

package com.alllist.list; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.List; public class Muster { /** * ----- Collection 接口 ----- * 1.集合类又被称为容器. * 2.数组的长度是固定的,集合的长度是可变的 * 3.数组和集合的区别: * 3.1.数组用来

Collection接口

在java.util包中提供了一些集合类,常用的有List.Set和Map类,其中List类和Set类继承了Collection接口.这些集合类 又称为容器,它们与数组不同,数组的长度是固定的,而集合的长度是可变的,数组用来存放基本数据类型的数据,集合用来存放类对象的引用. List接口.Set接口.Map接口以及Collection接口的主要特征如下: ● Collection接口是List接口和Set接口的父接口,通常情况下不被直接使用. ● List接口继承了Collection接口,Li

Collection接口&amp;List接口简介

Collection接口 是List.Set和Queue接口的父接口 定义了可用于操作List.Set和Queue的方法--增删改查(可以打开JDK的API文档查看这些方法) List接口及其实现类--ArrayList List是元素有序并且可以重复的集合,称为序列 List可以精确的控制每个元素的插入位置和删除某个位置的元素 ArrayList--数组序列,是List的一个重要是实现类(使用最频繁) ArrayList底层是由数组实现的 PS: 可以模拟学生选课来实现ArrayList的功能

java----数据结构与算法----JavaAPI:java.util.Collection接口

Java API--java.util.Collection接口 /** * @author chen * @date 20170317 * @description:本程序讲述Collection接口 * java.util.Collection * 概述:Collection接口是Set和List接口的父接口,Collection接口中定义了一些 * 用于集合元素操作的方法,被其子接口以及子接口的实现类所继承 * 构造函数 * java中接口不能有构造函数 * 成员函数: * [1]概述,由

Java基础之集合框架(Collection接口和List接口)

首先我们说说集合有什么作用. 一.集合的作用 1.在类的内部,对数据进行组织: 2.简单而快速的搜索大数量的条目: 3.有的集合接口,提供一系列排列有序的元素,并且可以在序列中间快速的插入或者删除有关元素: 例如:做广播操的时候,可以将学生插入到某排某列,反之也可以叫某排某列中的学生出列. 4.有的集合接口,提供了映射关系,可以通过关键字(key)去快速查找到对应的唯一对象,而这个关键字可以是任意类型. 例如:在吃饭的时候,众多铝饭盒中如何区别是自己的呢?在饭盒上刻独有的标志或贴纸条,这个标志和

编写高质量代码改善C#程序的157个建议——建议43:让接口中的泛型参数支持协变

建议43:让接口中的泛型参数支持协变 除了上一建议中提到的使用泛型参数兼容接口不可变性外,还有一种办法是为接口中的泛型声明加上out关键字来支持协变,如下所示: interface ISalary<out T> //使用out关键字 { void Pay(); } static void Main(string[] args) { ISalary<Programmer> s = new BaseSalaryCounter<Programmer>(); ISalary&l