5.1、泛型

概述:泛型是是JDK5中引入的特性,它提供了编译时类型安全检测机制,该机制允许在编译时检测到非法的类型,它的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。

泛型类:

// 格式:修饰符 class 类名<类型> { }
class Generic<T> {
private T t; public T getT() {
return t;
} public void setT(T t) {
this.t = t;
}
} public class Main {
public static void main(String[] args) {
Generic<String> g1 = new Generic<String>();
g1.setT("String");
System.out.println(g1.getT());
Generic<Integer> g2 = new Generic<Integer>();
g2.setT(100);
System.out.println(g2.getT());
Generic<Boolean> g3 = new Generic<Boolean>();
g3.setT(true);
System.out.println(g3.getT());
}
}

泛型方法:

// 格式:修饰符 <类型> 返回值类型 方法名(类型 变量名) { }
class Generic {
public <T> void show(T t) {
System.out.println(t);
}
} public class Main {
public static void main(String[] args) {
Generic g = new Generic();
g.show("String");
g.show(100);
g.show(true);
}
}

泛型接口:

// 修饰符 interface 接口名<类型> { }
interface Generic<T> {
void show(T t);
} class GenericImpl<T> implements Generic<T> {
@Override
public void show(T t) {
System.out.println(t);
}
} public class Main {
public static void main(String[] args) {
Generic<String> g1 = new GenericImpl<String>();
g1.show("String");
Generic<Integer> g2 = new GenericImpl<Integer>();
g2.show(30);
Generic<Boolean> g3 = new GenericImpl<Boolean>();
g3.show(true);
}
}

类型通配符:

类型通配符:<?>
List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型 类型通配符上限:<? extends 类型>
List<? extends Number>:它表示的类型是Number或者其子类型 类型通配符下限:<? super 类型>
List<? super Number>:它表示的类型是Number或者其父类型

可变参数:

public class Main {
public static void main(String[] args) {
System.out.println(sum(10));
System.out.println(sum(10, 20));
System.out.println(sum(10, 20, 30));
System.out.println(sum(10, 20, 30, 40));
System.out.println(sum(10, 20, 30, 40, 50));
System.out.println(sum(10, 20, 30, 40, 50, 60));
System.out.println(sum(10, 20, 30, 40, 50, 60, 70));
System.out.println(sum(10, 20, 30, 40, 50, 60, 70, 80));
System.out.println(sum(10, 20, 30, 40, 50, 60, 70, 80, 90));
System.out.println(sum(10, 20, 30, 40, 50, 60, 70, 80, 90, 100));
} // 格式:修饰符 返回值类型 方法名(数据类型… 变量名) { }
public static int sum(int... a) {
int sum = 0;
for (int i : a) {
sum += i;
}
return sum;
}
}

5.2、集合

概述:提供一种可变的存储模型,存储的数据容量可以随时发生改变

体系:

5.2.1、Collection接口

子接口特点:

  1. List接口:按照顺序存取,元素可以重复,有索引,可使用迭代器、增强for循环、普通for循环遍历
  2. Set接口:不按照顺序存取,元素不可以重复,没有索引,可使用迭代器、增强for循环遍历

通用方法:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; public class Main {
public static void main(String[] args) {
// 创建集合
Collection<String> collection = new ArrayList<String>(); // 添加元素
collection.add("张三");
collection.add("张三");
collection.add("李四");
collection.add("李四");
collection.add("王五");
collection.add("王五");
System.out.println(collection.toString()); // 移除元素
collection.remove("张三");
System.out.println(collection.toString()); // 判断元素
boolean isContains = collection.contains("李四");
System.out.println(isContains); // 判断集合是否为空
boolean isEmpty = collection.isEmpty();
System.out.println(isEmpty); // 获取集合元素个数
int size = collection.size();
System.out.println(size); // 用迭代器遍历集合
Iterator<String> iterator = collection.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
} // 用增强for循环遍历
for (String s : collection) {
System.out.println(s);
} // 添加另外集合元素
Collection<String> c = new ArrayList<String>();
c.add("小可爱");
c.add("大可爱");
collection.addAll(c);
System.out.println(collection.toString()); // 清空集合所有元素
collection.clear();
System.out.println(collection.toString());
}
}

5.2.2、List接口

子类特点:

  1. ArrayList集合:底层是数组结构实现,查询快、增删慢
  2. LinkedList集合:底层是链表结构实现,查询慢、增删快

通用方法:

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator; public class Main {
public static void main(String[] args) {
// 创建集合
List<String> list = new ArrayList<String>(); // 添加元素
list.add("张三");
list.add("张三");
list.add("李四");
list.add("李四");
list.add("王五");
list.add("王五");
System.out.println(list.toString()); // List独有方法:E get(int index)
String s = list.get(0);
System.out.println(s); // List独有方法:E set(int index, E element)
list.set(2, "xiaoqi");
System.out.println(list.toString()); // List独有方法:ListIterator<E> listIterator()
ListIterator<String> listIterator = list.listIterator();
// 使用列表迭代器:从前向后迭代
while (listIterator.hasNext()) {
System.out.println(listIterator.next());
}
// 使用列表迭代器:从后向前迭代
while (listIterator.hasPrevious()) {
System.out.println(listIterator.previous());
} // List独有遍历:普通for循环遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}

注意事项:

LinkedList集合的特有方法:

方法 说明
public void addFirst(E e) 在该列表开头插入指定的元素
public void addLast(E e) 在该列表末尾追加指定的元素
public E getFirst() 返回此列表中的第一个元素
public E getLast() 返回此列表中的最后一个元素
public E removeFirst() 从此列表中删除并返回第一个元素
public E removeLast() 从此列表中删除并返回最后一个元素

5.2.3、Set接口

子类特点:

  1. HashSet集合:底层由哈希表支撑,元素存取无序,对象添加需要重写hashCode和equals方法
  2. TreeSet集合:底层由二叉树支撑,元素顺序存取,对象排序需要继承Comparable接口重写compareTo方法、或者使用Comparator初始化

HashSet演示:

import java.util.Collection;
import java.util.HashSet; class Student {
private String name;
private Integer age; public Student() {
super();
} public Student(String name, Integer age) {
super();
this.name = name;
this.age = age;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Integer getAge() {
return age;
} public void setAge(Integer age) {
this.age = age;
} @Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
} @Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((age == null) ? 0 : age.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
} @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 (age == null) {
if (other.age != null)
return false;
} else if (!age.equals(other.age))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
} public class Main {
public static void main(String[] args) {
// 创建集合
Collection<Student> collection = new HashSet<Student>(); // 添加元素
collection.add(new Student("张三", 20));
collection.add(new Student("张三", 20));
collection.add(new Student("李四", 21));
collection.add(new Student("李四", 21));
collection.add(new Student("王五", 22));
collection.add(new Student("王五", 22));
System.out.println(collection.toString());
}
}

TreeSet演示:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序

import java.util.Collection;
import java.util.Comparator;
import java.util.TreeSet; class Student {
private String name;
private Integer age; public Student() {
super();
} public Student(String name, Integer age) {
super();
this.name = name;
this.age = age;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Integer getAge() {
return age;
} public void setAge(Integer age) {
this.age = age;
} @Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
} public class Main {
public static void main(String[] args) {
// 创建集合
Collection<Student> collection = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
// 主要条件
int sort1 = s1.getAge() - s2.getAge();
// 次要条件
int sort2 = sort1 == 0 ? s1.getName().compareTo(s2.getName()) : sort1;
return sort2;
}
}); // 添加元素
collection.add(new Student("王五", 22));
collection.add(new Student("王五", 22));
collection.add(new Student("张三1", 20));
collection.add(new Student("张三0", 20));
collection.add(new Student("李四0", 18));
collection.add(new Student("李四1", 18));
System.out.println(collection.toString());
}
}

5.2.4、Map接口

接口特点:

  1. 键值对映射关系
  2. 一个键对应一个值,键不可以重复,值可以重复
  3. 凡是对象作为HashMap的键时,对象添加需要重写hashCode和equals方法

通用方法:

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; public class Main {
public static void main(String[] args) {
// 创建集合
Map<String, String> map = new HashMap<String, String>(); // 添加元素
map.put("吕布", "貂蝉");
map.put("项羽", "虞姬");
map.put("郭靖", "黄蓉");
map.put("后裔", "嫦娥");
System.out.println(map.toString()); // 删除元素
map.remove("郭靖");
System.out.println(map.toString()); // 判断集合是否包含指定键
boolean containsKey = map.containsKey("吕布");
System.out.println(containsKey); // 判断集合是否包含指定值
boolean containsValue = map.containsValue("貂蝉");
System.out.println(containsValue); // 判断集合是否为空
boolean isEmpty = map.isEmpty();
System.out.println(isEmpty); // 获取集合元素个数
int size = map.size();
System.out.println(size); // 清空集合所有元素
map.clear();
System.out.println(map.toString()); // 添加另外集合元素
Map<String, String> m = new HashMap<String, String>();
m.put("张三", "李四");
m.put("王五", "小六");
map.putAll(m);
System.out.println(map.toString()); // 根据键获取值
System.out.println(map.get("张三")); // 获取所有键的集合
Set<String> keySet = map.keySet();
// 迭代器遍历
Iterator<String> keysIterator = keySet.iterator();
while (keysIterator.hasNext()) {
System.out.println(keysIterator.next());
}
// 增强for遍历
for (String key : keySet) {
System.out.println(key);
} // 获取所有值的集合
Collection<String> values = map.values();
// 迭代器遍历
Iterator<String> valuesIterator = values.iterator();
while (valuesIterator.hasNext()) {
System.out.println(valuesIterator.next());
}
// 增强for遍历
for (String value : values) {
System.out.println(value);
} // 获取所有键值对对象的集合
Set<Entry<String, String>> entrySet = map.entrySet();
// 迭代器遍历
Iterator<Entry<String, String>> entrySetIterator = entrySet.iterator();
while (entrySetIterator.hasNext()) {
Entry<String, String> entry = entrySetIterator.next();
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + ":" + value);
}
// 增强for遍历
for (Entry<String, String> entry : entrySet) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + ":" + value);
}
}
}

5.3、Collections类

描述:是针对集合操作的工具类

成员方法:

方法 描述
public static void sort(List list) 将指定的列表按升序排序
public static void reverse(List list) 反转指定列表中元素的顺序
public static void shuffle(List list) 使用默认的随机源随机排列指定的列表

示例代码:斗地主洗牌

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet; public class Main {
public static void main(String[] args) {
// 创建HashMap,键是编号,值是牌面
HashMap<Integer, String> hm = new HashMap<Integer, String>();
// 创建ArrayList,存储编号
ArrayList<Integer> array = new ArrayList<Integer>();
// 创建花色数组和点数数组
String[] colors = { "", "", "", "" };
String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2" };
// 从0开始往HashMap里面存储编号并存储对应的牌面,同时往ArrayList里面存储编号
int index = 0;
for (String number : numbers) {
for (String color : colors) {
hm.put(index, color + number);
array.add(index);
index++;
}
}
hm.put(index, "小王");
array.add(index);
index++;
hm.put(index, "大王");
array.add(index);
// 洗牌(洗的是编号)
Collections.shuffle(array);
// 发牌(发的是编号)
TreeSet<Integer> playerSet1 = new TreeSet<Integer>();
TreeSet<Integer> playerSet2 = new TreeSet<Integer>();
TreeSet<Integer> playerSet3 = new TreeSet<Integer>();
TreeSet<Integer> dpSet = new TreeSet<Integer>();
for (int i = 0; i < array.size(); i++) {
int x = array.get(i);
if (i >= array.size() - 3) {
dpSet.add(x);
} else if (i % 3 == 0) {
playerSet1.add(x);
} else if (i % 3 == 1) {
playerSet2.add(x);
} else if (i % 3 == 2) {
playerSet3.add(x);
}
}
// 调用看牌方法
lookPoker("player1", playerSet1, hm);
lookPoker("player2", playerSet2, hm);
lookPoker("player3", playerSet3, hm);
lookPoker("dp", dpSet, hm);
} /**
* 看牌方法
* @param name 玩家名称
* @param ts 牌面编号
* @param hm 牌面集合
*/
public static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) {
System.out.print(name + ": ");
for (Integer key : ts) {
String poker = hm.get(key);
System.out.print(poker + " ");
}
System.out.println();
}
}

第五章 泛型&集合的更多相关文章

  1. [Effective Java]第五章 泛型

    声明:原创作品,转载时请注明文章来自SAP师太技术博客( 博/客/园www.cnblogs.com):www.cnblogs.com/jiangzhengjun,并以超链接形式标明文章原始出处,否则将 ...

  2. 【读书笔记】C#高级编程 第五章 泛型

    (一)泛型概述 泛型不仅是C#编程语言的一部分,而且与程序集中的IL代码紧密地集成.泛型不仅是C#语言的一种结构,而且是CLR定义的.有了泛型就可以创建独立于被包含类型的类和方法了. 1.性能 泛型的 ...

  3. 第三章泛型集合ArrayList 和Hashtable

    第三章泛型集集合 ArrayList 变量名 = new ArrayList();  //相当与一个容器 他的执行using 是  using System.Collections; 变量名.ADD( ...

  4. C#高级编程学习一-----------------第五章泛型

    三层架构之泛型应用 概述 1.命名约定 泛型类型以T开头或就是T. 2.泛型类 2.1.创建泛型类

  5. 《Java编程思想》笔记 第十五章 泛型

    1 泛型 “泛型”意思就是适用于许多类型. 使用泛型的目的之一: 指定容器持有什么类型,让编译器确保正确性,而不是在运行期发现错误. 这个容器可以看成是有其他类型对象作为成员的类,而不单单只是JDK中 ...

  6. Programming Entity Framework-dbContext 学习笔记第五章

    ### Programming Entity Framework-dbContext 学习笔记 第五章 将图表添加到Context中的方式及容易出现的错误 方法 结果 警告 Add Root 图标中的 ...

  7. 【深入学习.Net】.泛型集合【体检管理系统】

    基于泛型List的体检管理系统(蜗牛爬坡) 第五章[体检管理系统] 一.项目展示图(基于.net core6.0) 二.首先准备两个Model类 HealthCheckItem(项目类):Name(项 ...

  8. 《Entity Framework 6 Recipes》中文翻译系列 (22) -----第五章 加载实体和导航属性之延迟加载

    翻译的初衷以及为什么选择<Entity Framework 6 Recipes>来学习,请看本系列开篇 第五章 加载实体和导航属性 实体框架提供了非常棒的建模环境,它允许开发人员可视化地使 ...

  9. python学习心得第五章

    python学习心得第五章 1.冒泡排序: 冒泡是一种基础的算法,通过这算法可以将一堆值进行有效的排列,可以是从大到小,可以从小到大,条件是任意给出的. 冒泡的原理: 将需要比较的数(n个)有序的两个 ...

随机推荐

  1. vue项目chunk包loading失败解决办法

    错误截图: 解决方法: // loading chunk 出错处理 router.onError((error) => { const pattern = /Loading chunk (\d) ...

  2. Maven Jar包下载失败及解决方案

    我是阿福,公众号「阿福聊编程」作者,一个在后端技术路上摸盘滚打的程序员,在进阶的路上,共勉! 文章已收录在 JavaSharing 中,包含Java技术文章,面试指南,资源分享. 明显的下载失败 具体 ...

  3. css如何将图片横向平铺?

    在CSS中,可以使用background(背景)属性来添加图片,默认图片是向x轴和y轴重复.那么css如何将图片横向平铺?下面本篇文章就来给大家介绍一下使用CSS将图片横向平铺的方法,希望对大家有所帮 ...

  4. SpringBoot常用数据源配置

    #mysql8.X url: jdbc:mysql://localhost:3306/yourdbname?serverTimezone=UTC&useSSL=false&allowP ...

  5. 【asp.net core 系列】15 自定义Identity

    0. 前言 在之前的文章中简单介绍了一下asp.net core中的Identity,这篇文章将继续针对Identity进行进一步的展开. 1. 给Identity添加额外的信息 在<[asp. ...

  6. spring-boot 应用 报错 No qualifying bean of type XXXXX.***Mapper

    报错类型 NoSuchBeanDefinitionException.No qualifying bean of type  XXXXX.***Mapper 报错信息详情 Caused by: org ...

  7. 响应式布局rem、rem方法封装、移动端响应式布局

    相信大家在做移动端的时候都会做各个手机的适配这种适配就是响应式布局在之前做网站的响应式从pc到手机用的是媒体查询 @media screen and (max-width: 300px){} 最大宽度 ...

  8. 小谢第36问:elemet - table表格修改后表格行高亮显示且定位到当前行当前页

    第一次做这个需求得时候很乱,总是在表格页和修改页徘徊,总觉得什么都会,但是就是做不出自己想要得效果 其实如果先把思路搞清楚,这个问题得知识点却是不多,以下是我对表格高亮显示得思路: 首先,我会从已知得 ...

  9. SqlServer同义词

    最近在项目中遇到跨库操作具有相同表结构的数据表的问题.(A库中的数据表a和B库中的数据表b,两者表结构相同) 跨库操作中我们一般是为了实现不同数据库中表字段信息,字段状态等实时同步,可能很多人会想到使 ...

  10. Python Ethical Hacking - Malware Packaging(2)

    PACKAGING FOR WINDOWS FROM LINUX For best results package the program from the same OS as the target ...