1 List集合
1 概述
List是一个接口，是Collection的子类接口，所以要通过实现类来访问
List是一个有序集合，可以通过索引，来指定位置
List集合中允许出现重复的数
package List;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Test01$
* @Description:
* @Time 2021/3/2$ 22:18$
* @Author-Email FONG_y@outlook.com
*/
public class Test01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("iphone");
list.add("ipad");
list.add("ipod");
//List集合特有的添加元素方法
list.add(1,"iMac");
System.out.println(list);
}
}
2 常用方法
| 方法名 | 说明 |
|---|---|
void add(int index , E e) | 在指定索引位置添加元素 |
E remove(int index) | 删除指定索引位置的元素 ，返回被删除的元素 |
E set(int index , E e) | 修改指定索引位置的元素，返回被修改前的元素 |
E get(int index) | 获取指定索引位置的元素 |
package List;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Test02$
* @Description: List的常用方法
* @Time 2021/3/2$ 22:24$
* @Author-Email FONG_y@outlook.com
*/
public class Test02 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("iPhone");
list.add("iPad");
list.add("iPod");
list.add(1,"iMac");
System.out.println(list); // [iPhone, iMac, iPad, iPod]
System.out.println(list.remove(3)); // iPod
System.out.println(list.set(2,"iWatch")); // iPad
System.out.println(list.get(1)); // iMac
}
}
3 遍历方式
package List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @ClassName Test03$
* @Description: list集合的五种遍历方式
* @Time 2021/3/2$ 22:42$
* @Author-Email FONG_y@outlook.com
*/
public class Test03 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("iPhone");
list.add("iPad");
list.add("iPod");
list.add(1,"iMac");
//第一种
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("===============");
//第二种
for (String str : list) {
System.out.println(str);
}
System.out.println("===============");
//第三种
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("===============");
//第四种
list.stream().forEach(System.out::println);
System.out.println("===============");
//第五种
list.forEach(System.out::println);
}
}
4 并发性修改异常
package List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @ClassName Test04$
* @Description:
* @Time 2021/3/2$ 22:52$
* @Author-Email FONG_y@outlook.com
*/
public class Test04 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("iPhone");
list.add("iPad");
list.add("iPod");
list.add(1,"iMac");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
String next = iterator.next();
if (next.equals("iPhone")){
list.add("AirPods");
}
}
System.out.println(list);
}
}
以上的这个代码块出现了异常 也就是这里要讲的并发性异常ConcurrentModificationException
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at List.Test04.main(Test04.java:24)
我们使用迭代器去遍历list集合的时候，我们说过这个并不是集合本身，而在遍历的时候，迭代器的内部会有一个获取迭代器对象时候生成的预期迭代元素的个数，当我们满足了if后面那个条件后，我们在list集合添加了元素，导致了预期遍历的元素个数与原始集合的元素个数对应错误，出现异常。
想要解决这个异常就是使用最普通的for循环遍历：
package List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @ClassName Test04$
* @Description: 并发性修改异常
* @Time 2021/3/2$ 22:52$
* @Author-Email FONG_y@outlook.com
*/
public class Test04 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("iPhone");
list.add("iPad");
list.add("iPod");
list.add(1,"iMac");
for (int i = 0; i < list.size(); i++) {
if (list.get(i).equals("iPhone")){
list.add("AirPods");
}
}
System.out.println(list);
}
}
5 ListIterator ==> List集合的专属迭代器
常用方法：
| 方法名 | 说明 |
|---|---|
E next() | 返回下一个 |
boolean hasNext() | 判断有没有下一个 |
E previous | 返回上一个 |
boolean hasPrevious | 判断有没有上一个 |
void add(E e) | 添加元素 |
package List;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/**
* @ClassName Test05$
* @Description: ListIterator
* @Time 2021/3/2$ 23:10$
* @Author-Email FONG_y@outlook.com
*/
public class Test05 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("iPhone");
list.add("iPad");
list.add("iPod");
list.add(1,"iMac");
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()){
System.out.println(listIterator.next());
}
while (listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}
while (listIterator.hasNext()){
String next = listIterator.next();
if (next.equals("iPhone")){
listIterator.add("AirPods");
}
}
System.out.println(list);
}
}
6 List集合的特点
ArrayLIst:底层数据结构是数组，修改查询快，添加删除慢
LinkedList:底层数据结构是链表，修改查询慢，添加删除快
7 LinkedList
常用方法：
| 方法名 | 说明 |
|---|---|
public void addFirst(E e) | 头添加 |
public void addLast(E e) | 尾添加 |
public E getFirst() | 获取头 |
public E getLast() | 获取尾 |
public E removeFirst() | 移除头 并返回头 |
public E removeLast() | 移除尾 并返回尾 |
package List;
import java.util.LinkedList;
/**
* @ClassName Test06$
* @Description: LinkedList
* @Time 2021/3/4$ 8:07$
* @Author-Email FONG_y@outlook.com
*/
public class Test06 {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("111");
linkedList.add("222");
linkedList.add("333");
linkedList.add("444");
linkedList.addFirst("AAA");
linkedList.addLast("ZZZ");
System.out.println(linkedList); //[AAA, 111, 222, 333, 444, ZZZ]
System.out.println("============");
System.out.println(linkedList.getFirst()); //AAA
System.out.println(linkedList.getLast()); //ZZZ
System.out.println(linkedList.removeFirst());//AAA
System.out.println(linkedList.removeLast());//ZZZ
System.out.println(linkedList);//[111, 222, 333, 444]
}
}
2 数据结构简介
程序 = 数据结构 + 算法
时间优先 、 空间优先 - 需求
Java对空间基本没有什么需求 运行端通常是PC或者服务器
底层写的程序 如果在设备里运行不了，只能改
Java PC平台 或者 服务器平台 如果设备运行不了，程序员可以要求客户升级设备
1 栈模型
只有一个开口， 数据的流向是双向的，先进的后出，后进的先出
栈底元素：最先进入模型的元素
栈顶元素：最后进入模型的元素
进栈/压栈：数据进入栈模型的元素
出栈/弹栈：数据离开栈模型的元素
package datastructure;
import java.util.Scanner;
/**
* @ClassName Test01$
* @Description: 栈模型递归案例
* @Time 2021/3/4$ 8:58$
* @Author-Email FONG_y@outlook.com
*/
public class Test01 {
public static void main(String[] args) {
System.out.println("请输入你想求的累加和的数字：");
System.out.println(mySum(new Scanner(System.in).nextInt()));
}
private static int mySum(int nextInt) {
if (nextInt == 1){
return 1;
}
// n 的累加和 就是 n + n-1 的累加和
return nextInt + mySum(nextInt - 1);
}
}
2 队列模型
队列模型就是一个走廊一样的，两端都有开口，先进先出，后进后出
package datastructure;
/**
* @ClassName Test02$
* @Description: 队列模型
* @Time 2021/3/4$ 9:05$
* @Author-Email FONG_y@outlook.com
*/
public class Test02 {
public static void main(String[] args) {
method01();
method02();
method03();
}
private static void method03() {
System.out.println("Method03进入队列了");
System.out.println("Method03离开队列了");
}
private static void method02() {
System.out.println("Method02进入队列了");
System.out.println("Method02离开队列了");
}
private static void method01() {
System.out.println("Method01进入队列了");
System.out.println("Method01离开队列了");
}
}
3 数组模型
数组就是相同数据类型的集合 ，这种模型的特点是 ：查询和修改快，删除和添加慢
package datastructure;
import java.util.Arrays;
import java.util.Scanner;
/**
* @ClassName Test03$
* @Description: 数组模型 添加元素
* @Time 2021/3/4$ 9:09$
* @Author-Email FONG_y@outlook.com
*/
public class Test03 {
public static void main(String[] args) {
int[] arr = new int[10];
//依次向前九位赋值
for (int i = 1; i <= 9; i++) {
arr[i-1] = i ;
}
System.out.println(Arrays.toString(arr));
System.out.println("请输入一个1-9的值：");
int num = new Scanner(System.in).nextInt();
int place;
for (place = 0; place < arr.length - 1; place++) {
//找到这个存放的位置后退出
if (arr[place] > num){
break;
}
}
System.out.println(place);
//依次向后挪位置（从后面的开始挪）
for (int i = arr.length - 1; i > place; i--) {
arr[i] = arr[i-1];
}
//将num值放进数组
arr[place] = num ;
System.out.println(Arrays.toString(arr));
}
}
另一种插入元素的方法：
package datastructure;
import java.util.Arrays;
import java.util.Scanner;
/**
* @ClassName Test04$
* @Description: 数组模型 添加元素
* @Time 2021/3/4$ 17:58$
* @Author-Email FONG_y@outlook.com
*/
public class Test04 {
public static void main(String[] args) {
int[] arr = new int[10];
//依次向前九位赋值
for (int i = 1; i <= 9; i++) {
arr[i-1] = i ;
}
System.out.println(Arrays.toString(arr));
System.out.println("请输入一个1-9的值：");
int num = new Scanner(System.in).nextInt();
int place;
for (place = 0; place < arr.length - 1; place++) {
//找到这个存放的位置后退出
if (arr[place] > num){
break;
}
}
for (int i = place , t; i < arr.length; i++) {
t = arr[i];
arr[i] = num ;
num = t ;
}
System.out.println(Arrays.toString(arr));
}
}
4 链表模型
查询修改慢 增加删除快
节点：一个数据单元
数据域：存储实际数据的地方
指针域：存储下一个节点位置
3 Set集合
1 概述
Set也是一个接口，也需要通过实现类来操作
特点：
1、不能包含重复的元素
2、没有索引，不能通过普通的for循环遍历
package Set;
import java.util.HashSet;
import java.util.Set;
/**
* @ClassName Test01$
* @Description: Set 简单案例
* @Time 2021/3/5$ 8:56$
* @Author-Email FONG_y@outlook.com
*/
public class Test01 {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("水星");
set.add("金星");
set.add("地球");
set.add("火星");
set.add("木星");
set.add("土星");
set.add("天王星");
set.add("海王星");
//输出结果不保证读写顺序
System.out.println(set); //[天王星, 海王星, 水星, 地球, 火星, 土星, 木星, 金星]
}
}
2 哈希值
哈希值就是jdk根据对象的 地址 或者 字符串 或者 数字 计算出来的一个整型数值
一般情况下 不同对象的哈希值不同 但是偶尔也会出现哈希值相同 但是对象不同的情况
哈希值不同的一定不是同一个对象 哈希值相同的不一定是相同对象
package Set;
import java.nio.charset.StandardCharsets;
/**
* @ClassName Test02$
* @Description: 哈希值
* @Time 2021/3/6$ 8:46$
* @Author-Email FONG_y@outlook.com
*/
public class Test02 {
public static void main(String[] args) {
String s1 = "Hello World";
String s2 = "Hello HashSet";
String s3 = new String("Hello HashSet".getBytes(StandardCharsets.UTF_8));
//相同对象 多次调用hashcode方法返回的值是 相同的
System.out.println(s1.hashCode()); //-862545276
System.out.println(s1.hashCode()); //-862545276
System.out.println(s1.hashCode()); //-862545276
System.out.println("===================");
//相同的字符串 采用的是常量池中的地址作为hashcode的结算依据
System.out.println("Hello HashSet".hashCode()); //-804992282
System.out.println(s2.hashCode()); //-804992282
System.out.println(s3.hashCode()); //-804992282
System.out.println("===================");
//不同对象 即使是同一个类、都是空对象 ，但是对象地址不同 调用hashcode返回的值也不同
System.out.println(new Object().hashCode());
System.out.println(new Object().hashCode());
System.out.println(new Object().hashCode());
System.out.println("===================");
//hashcode相同 对象不同的例子
System.out.println("ABCDEa123abc".hashCode()); //165374702
System.out.println("ABCDFB123abc".hashCode()); //165374702
}
}
3 HashSet
HashSet 去重原理是先对比HashCode 再对比 equal（可重写）
特点：
1、底层数据结构是“哈希表”
2、不保证集合的读写顺序
3、没有带索引的方法
4、不允许出现重复值
4 哈希表
哈希表是 由数组+链表实现的一种数据结构
哈希表的构造方法的参数中，有一个16位长度的数组 ，用hashcode%16来选择储存位置
5 LinkedHashSet
是哈希表与链表实现的set接口
特点：
1、具有可预测读写顺序
2、由 链表 保证读写顺序 ， 由 哈希表 保证元素的唯一性
package Set;
import java.util.LinkedHashSet;
import java.util.Set;
/**
* @ClassName Test03$
* @Description:
* @Time 2021/3/6$ 9:32$
* @Author-Email FONG_y@outlook.com
*/
public class Test03 {
public static void main(String[] args) {
LinkedHashSet<String> linkedHashSet = new LinkedHashSet();
linkedHashSet.add("水星");
linkedHashSet.add("金星");
linkedHashSet.add("地球");
linkedHashSet.add("火星");
linkedHashSet.add("木星");
linkedHashSet.add("土星");
linkedHashSet.add("天王星");
linkedHashSet.add("海王星");
//即便是两次输出海王星 也没有 被收进集合中
linkedHashSet.add("海王星");
System.out.println(linkedHashSet);
}
}
6 TreeSet
特点：
1、有序集合，这里的有序 指的是按照一定的规则有序 并不是读写顺序
2、通过构造方法来指定规则方式：
TreeSet()：根据自然规则排序
TreeSet(Comparator com)：根据自定义规则进行排序
package Set;
import java.util.Comparator;
import java.util.TreeSet;
/**
* @ClassName Test04$
* @Description: 自定义规则排序
* @Time 2021/3/6$ 9:39$
* @Author-Email FONG_y@outlook.com
*/
public class Test04 {
public static void main(String[] args) {
TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println("o1 = " + o1);
System.out.println("o2 = " + o2);
//如果返回值大于0 说明后面插入的元素>之前的元素 向后排列
//如果返回值小于0 说明后面插入的元素<之前的元素 向前排列
//return o1 - o2; //升序排列
//return o2 - o1; //降序排列
return 0; //说明后面插入的元素等于前面插入的元素 所以不插入
}
});
ts.add(444);
ts.add(111);
ts.add(333);
ts.add(555);
ts.add(222);
System.out.println(ts);
}
}
使用TreeSet存储学生对象，范例1：
package Set;
import java.util.Comparator;
/**
* @ClassName Student$
* @Description:
* @Time 2021/3/18$ 12:02$
* @Author-Email FONG_y@outlook.com
*/
public class Student implements Comparable<Student> {
private String name;
private int age;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Student stu) {
/*System.out.println("this.getAge() = " + this.getAge());
System.out.println("stu.getAge() = " + stu.getAge());*/
int res = this.getAge() - stu.getAge();
//按照年龄排序，如果年龄相同则按照姓名排序
return 0 == res ? this.getName().compareTo(stu.getName()):res;
}
}
//===============================================================================
package Set;
import java.util.Comparator;
import java.util.TreeSet;
/**
* @ClassName Test05$
* @Description: TreeSet 存储学生类对象
* @Time 2021/3/18$ 12:02$
* @Author-Email FONG_y@outlook.com
*/
public class Test05 {
public static void main(String[] args) {
TreeSet<Student> students = new TreeSet<>();
students.add(new Student("张三",18));
students.add(new Student("李四",15));
students.add(new Student("王五",17));
students.add(new Student("赵六",18));
for (Student stus : students){
System.out.println(stus);
}
}
}
使用TreeSet存储学生对象，范例2：
package Set;
/**
* @ClassName Student$
* @Description:
* @Time 2021/3/18$ 12:02$
* @Author-Email FONG_y@outlook.com
*/
public class Student {
private String name;
private int age;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
//==============================================================
package Set;
import java.util.Comparator;
import java.util.TreeSet;
/**
* @ClassName Test05$
* @Description: TreeSet 存储学生类对象
* @Time 2021/3/18$ 12:02$
* @Author-Email FONG_y@outlook.com
*/
public class Test05 {
public static void main(String[] args) {
TreeSet<Student> students = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int res = o1.getAge()-o2.getAge();
//学生o1与o2的年龄是否相等，如果相等，对比姓名，如果不相等，返回res的值
//res > 0 ==> o1.getAge() > o2.getAge() 升序
//res < 0 ==> o1.getAge() < o2.getAge() 降序
return 0 == res ? o1.getName().compareTo(o2.getName()) : res;
}
});
students.add(new Student("张三",18));
students.add(new Student("李四",15));
students.add(new Student("王五",17));
students.add(new Student("赵六",18));
for (Student stus : students){
System.out.println(stus);
}
}
}
//===================================================================
双色球TreeSet版本：
package Set;
import java.util.Random;
import java.util.TreeSet;
/**
* @ClassName Test06$
* @Description: 双色球TreeSet版本
* @Time 2021/3/18$ 12:26$
* @Author-Email FONG_y@outlook.com
*/
public class Test06 {
public static void main(String[] args) {
Random random = new Random();
TreeSet<Integer> redBall = new TreeSet<>();
Integer blueBall = random.nextInt(16)+1;
while (redBall.size() < 6){
redBall.add(random.nextInt(33)+1);
}
System.out.print("redBall : ");
for (Integer redBalls : redBall){
System.out.printf("%02d " , redBalls);
}
System.out.println("blueBall : " + blueBall);
}
}
4 泛型
泛型是JDK5后出现的新特性，一种安全监测机制，本质就是将数据类型参数化，也就是操作的数据类型可以作为参数进行传递
泛型类、泛型方法、泛型接口
1 定义格式
<类型>：指定一种数据类型
类型1，类型2：指定多种数据类型
2 指定泛型的好处
可以把有可能案出现在运行阶段的问题拿到编译阶段上来（提高错误等级，提高开发效率）
避免程序中出现的强制数据类型转换问题
3 泛型类
通常情况下，我们使用的都是系统提供给我们的泛型类。很少自己定义
package Generic;
/**
* @ClassName Generic$
* @Description: 泛型类 常用的泛型表示 E/K/T/V
* @Time 2021/3/21$ 22:15$
* @Author-Email FONG_y@outlook.com
*/
public class Generic <T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
=====================================================================
package Generic;
import Set.Student;
/**
* @ClassName Test01$
* @Description: 泛型测试类
* @Time 2021/3/21$ 22:14$
* @Author-Email FONG_y@outlook.com
*/
public class Test01 {
public static void main(String[] args) {
Generic<Integer> intG = new Generic<Integer>();
intG.setT(1234);
System.out.println(intG.getT() + 1234);
Generic<String> strG = new Generic<String>();
strG.setT("1234");
System.out.println(strG.getT() + 1234);
Generic<Student> stuG = new Generic<Student>();
stuG.setT(new Student("胖熊",1));
System.out.println(stuG.getT());
}
}
4 泛型方法
package Generic;
/**
* @ClassName Generic$
* @Description: 泛型类 常用的泛型表示 E/K/T/V
* @Time 2021/3/21$ 22:15$
* @Author-Email FONG_y@outlook.com
*/
public class Generic <T> {
public <T> void show(T t) {
System.out.println(t);
}
}
==============================================
package Generic;
import Set.Student;
/**
* @ClassName Test02$
* @Description: 泛型方法测试类
* @Time 2021/3/21$ 22:58$
* @Author-Email FONG_y@outlook.com
*/
public class Test02 {
public static void main(String[] args) {
Generic generic = new Generic();
generic.show("string");
generic.show(604);
generic.show(6.04f);
generic.show(6.04);
generic.show(true);
generic.show('Y');
generic.show(new Student("胖熊",1));
}
}
5 泛型接口
package Generic;
/**
* @ClassName Generic$
* @Description: 泛型类 常用的泛型表示 E/K/T/V
* @Time 2021/3/21$ 22:15$
* @Author-Email FONG_y@outlook.com
*/
public interface Generic <T> {
void show(T t);
}
==============================================
package Generic;
/**
* @ClassName GenericImpl$
* @Description:
* @Time 2021/3/21$ 23:18$
* @Author-Email FONG_y@outlook.com
*/
public class GenericImpl<T> implements Generic<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
==============================================
package Generic;
/**
* @ClassName Test03$
* @Description: 泛型接口的测试类
* @Time 2021/3/21$ 23:16$
* @Author-Email FONG_y@outlook.com
*/
public class Test03 {
public static void main(String[] args) {
GenericImpl<String> stringGeneric = new GenericImpl<String>();
stringGeneric.show("我是一个字符串");
Generic<Float> floatGeneric = new Generic<Float>() {
@Override
public void show(Float aFloat) {
System.out.println(aFloat);
}
};
floatGeneric.show(6.04f);
}
}
6 泛型的通配符
package Generic;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Test04$
* @Description: 泛型通配符
* @Time 2021/3/21$ 23:22$
* @Author-Email FONG_y@outlook.com
*/
public class Test04 {
public static void main(String[] args) {
//通用类型通配符 ?
ArrayList<?> list01 = new ArrayList<Object>();
ArrayList<?> list02 = new ArrayList<String>();
ArrayList<?> list03 = new ArrayList<Float>();
ArrayList<?> list04 = new ArrayList<Integer>();
ArrayList<?> list05 = new ArrayList<Boolean>();
//类型通配符的上限 <? extends 类型>
List<? extends Number> list06 = new ArrayList<Number>();
List<? extends Number> list07 = new ArrayList<Integer>();
List<? extends Number> list08 = new ArrayList<Float>();
List<? extends Number> list09 = new ArrayList<Double>();
//List<? extends Number> list10 = new ArrayList<Object>(); //超过上限
//类型通配符的下限 <? super 类型>
List<? super Number> list11 = new ArrayList<Number>();
List<? super Number> list12 = new ArrayList<Object>();
//List<? super Number> list13 = new ArrayList<Float>(); //超过下限
}
}
7 可变长参数
参数的个数可以不确定
格式：修饰符 返回值类型 方法名（数据类型 ... 变量名）
EX：public static void sum(int ... a)
package Generic;
/**
* @ClassName Test05$
* @Description: 可变长参数
* @Time 2021/3/22$ 0:01$
* @Author-Email FONG_y@outlook.com
*/
public class Test05 {
public static void main(String[] args) {
sum(1,1,2);
sum(2,1,2,3);
sum(3,1,2,3,4);
sum(4,1,2,3,4,5);
int[] arr = {1,2,3,4,5};
sum(5,arr);
}
private static void sum(int count, int ... arr){
int sum = 0;
for (int num:arr){
sum += num;
}
System.out.println("第" + count + "次 sum + " + sum);
}
}
asList 方法 返回由指定数组固定大小的集合列表
package Generic;
import java.util.Arrays;
import java.util.List;
/**
* @ClassName Test06$
* @Description: asList方法
* @Time 2021/3/22$ 0:06$
* @Author-Email FONG_y@outlook.com
*/
public class Test06 {
public static void main(String[] args) {
List<String> list = Arrays.asList("One","Two","Three","Four","Five");
//通过asList 方法获取的集合长度不能发生变化
//list.add("Six"); //报错：UnsupportedOperationException
//list.remove("One"); //报错：UnsupportedOperationException
list.set(0,"First");
System.out.println(list);
}
}
5 Map集合
1 概述
interface Map<K, V>:K表示键Key V表示值Value
键不可以重复，值可以重复
package Map;
import java.util.HashMap;
import java.util.Map;
/**
* @ClassName Test01$
* @Description: Map集合范例
* @Time 2021/3/22$ 10:36$
* @Author-Email FONG_y@outlook.com
*/
public class Test01 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
//put进去的值 如果不在集合里，代表创建
map.put("STU001","LUFFY");
map.put("STU002","ZORO");
map.put("STU003","USOPP");
map.put("STU004","SANJI");
map.put("STU005","NAMI");
map.put("STU006","BIGMOM");
map.put("STU007","ROBIN");
map.put("STU008","FRANKY");
map.put("STU009","BROOK");
//put进去的值 已经在集合里，代表修改
map.put("STU006","CHOPPER");
System.out.println(map);
}
}
2 常用方法
| 方法名 | 说明 |
|---|---|
V put (K key,V value) | 添加\修改元素 |
V remove(Object key) | 通过键删除元素 |
boolean containsKey(Object key) | 判断键是否存在 |
boolean containsValue(Object Value) | 判断值是否存在 |
boolean isEmpty() | 判空 |
int size() | 返回集合的长度 |
void clean() | 清空集合 |
package Map;
import java.util.HashMap;
import java.util.Map;
/**
* @ClassName Test01$
* @Description: Map的常用方法
* @Time 2021/3/22$ 10:36$
* @Author-Email FONG_y@outlook.com
*/
public class Test02 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
//put进去的值 如果不在集合里，代表创建
map.put("STU001","LUFFY");
map.put("STU002","ZORO");
map.put("STU003","USOPP");
map.put("STU004","SANJI");
map.put("STU005","NAMI");
map.put("STU006","CHOPPER");
map.put("STU007","ROBIN");
map.put("STU008","FRANKY");
map.put("STU009","BROOK");
map.put("STU010","BIGMOM");
System.out.println(map.remove("STU010")); //存在，删除返回Value值
System.out.println(map.remove("STU010")); //不存在，返回null
System.out.println(map.containsKey("STU002")); //存在，返回true
System.out.println(map.containsValue("BIGMOM")); //存在，返回false
map.clear(); //清空集合
System.out.println(map.isEmpty()); //集合是否为空，是 返回true
System.out.println(map.size()); //返回集合长度
}
}
3 获取功能
| 方法名 | 说明 |
|---|---|
V get(Object Key() | 根据键获取值 |
Set<K> KeySet() | 获取所有键的集合 |
Collection<V> values() | 获取所有值的集合 |
Set<Map,Entry<K,V>> entrySet() | 获取所有键值对的集合 |
package Map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @ClassName Test01$
* @Description:
* @Time 2021/3/22$ 10:36$
* @Author-Email FONG_y@outlook.com
*/
public class Test03 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("STU001","LUFFY");
map.put("STU002","ZORO");
map.put("STU003","USOPP");
map.put("STU004","SANJI");
map.put("STU005","NAMI");
map.put("STU006","CHOPPER");
map.put("STU007","ROBIN");
map.put("STU008","FRANKY");
map.put("STU009","BROOK");
//遍历map集合的方法1：获取所有键的集合
Set<String> keySet = map.keySet();
for (String key : keySet){
System.out.println(key + " <==> " + map.get(key));
}
System.out.println("========================================");
//遍历map集合的方法2：获取所有值的集合（取不到键）
Collection<String> values = map.values();
for (String value : values){
System.out.println(value);
}
System.out.println("========================================");
//遍历map集合的方法3：获取所有键值对的集合
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for (Map.Entry<String, String> es : entrySet){
String key = es.getKey();
String value = es.getValue();
System.out.println(key + " <==> " + value);
}
}
}
4 存储自定义对象并遍历
package Map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @ClassName Test01$
* @Description: map存储学生对象并遍历案例
* @Time 2021/3/22$ 10:36$
* @Author-Email FONG_y@outlook.com
*/
public class Test04 {
public static void main(String[] args) {
HashMap<String, Student> hashMap = new HashMap<>();
hashMap.put("STU001",new Student("LUFFY","boy"));
hashMap.put("STU002",new Student("ZORO","boy"));
hashMap.put("STU003",new Student("USOPP","boy"));
hashMap.put("STU004",new Student("NAMI","girl"));
hashMap.put("STU005",new Student("SANJI","boy"));
hashMap.put("STU006",new Student("CHOPPER","boy"));
hashMap.put("STU007",new Student("ROBIN","girl"));
hashMap.put("STU008",new Student("FRANKY","boy"));
hashMap.put("STU009",new Student("BROOK","boy"));
Set<String> keySet = hashMap.keySet();
for (String ks : keySet){
Student student = hashMap.get(ks);
System.out.println(ks + " <==> " + student.getName() + " , " + student.getSex());
}
System.out.println("========================");
Set<Map.Entry<String, Student>> entrySet = hashMap.entrySet();
for (Map.Entry<String , Student> es : entrySet){
Student student = es.getValue();
System.out.println(es.getKey() + " <==> " + student.getName() + " , " + student.getSex());
}
}
}
5 集合的嵌套
package Map;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @ClassName Test01$
* @Description: ArrayList 集合中存储 HashMap 的集合元素
* @Time 2021/3/22$ 10:36$
* @Author-Email FONG_y@outlook.com
*/
public class Test05 {
public static void main(String[] args) {
ArrayList<HashMap<String, String>> arrayList = new ArrayList<>();
HashMap<String, String> hashMap01 = new HashMap<>();
hashMap01.put("新一","小兰");
hashMap01.put("小丸子","花轮");
HashMap<String, String> hashMap02 = new HashMap<>();
hashMap02.put("叶天瑜","单均昊");
hashMap02.put("夏之星","仲天骐");
arrayList.add(hashMap01);
arrayList.add(hashMap02);
for (HashMap<String ,String > al : arrayList){
Set<String> keySet = al.keySet();
for (String ks : keySet){
String value = al.get(ks);//获取的是值
System.out.println(ks + " <==> " + value);
}
}
System.out.println("=====================");
for (HashMap<String ,String > al:arrayList){
Set<Map.Entry<String, String>> entrySet = al.entrySet();
for (Map.Entry<String, String> es : entrySet){
String key = es.getKey();
String value = es.getValue();
System.out.println(key + " <==> " + value);
}
}
}
}
package Map;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @ClassName Test01$
* @Description: HashMap集合中存储ArrayList集合元素
* @Time 2021/3/22$ 10:36$
* @Author-Email FONG_y@outlook.com
*/
public class Test06 {
public static void main(String[] args) {
HashMap<String, ArrayList<String>> hashMap = new HashMap<>();
ArrayList<String> arrayList01 = new ArrayList<>();
arrayList01.add("红发");
arrayList01.add("白胡子");
arrayList01.add("大妈");
arrayList01.add("凯多");
ArrayList<String> arrayList02 = new ArrayList<>();
arrayList02.add("黄猿");
arrayList02.add("青雉");
arrayList02.add("赤犬");
ArrayList<String> arrayList03 = new ArrayList<>();
arrayList03.add("路飞");
arrayList03.add("艾斯");
arrayList03.add("萨博");
hashMap.put("四皇",arrayList01);
hashMap.put("海军元帅",arrayList02);
hashMap.put("三兄弟",arrayList03);
Set<String> keySet = hashMap.keySet();
for (String ks : keySet){
System.out.println(ks);
ArrayList<String> names = hashMap.get(ks);
for (String name : names){
System.out.println("\t" + name);
}
}
System.out.println("=========================");
Set<Map.Entry<String, ArrayList<String>>> entrySet = hashMap.entrySet();
for (Map.Entry<String, ArrayList<String>> es : entrySet){
System.out.println(es.getKey());
ArrayList<String> names = es.getValue();
for (String name : names){
System.out.println("\t" + name);
}
}
}
}
6 统计应用
package Map;
import java.util.Scanner;
import java.util.TreeMap;
/**
* @ClassName Test01$
* @Description: 统计键盘输入的字符数数量
* @Time 2021/3/22$ 10:36$
* @Author-Email FONG_y@outlook.com
*/
public class Test07 {
public static void main(String[] args) {
System.out.println("请输入你想统计的字符串: ");
String line = new Scanner(System.in).nextLine();
TreeMap<Character, Integer> map = new TreeMap<>();
for (int i = 0; i < line.length(); i++) {
char key = line.charAt(i);
Integer count = map.get(key);
if (count == null){
map.put(key,1);
}else {
map.put(key,++count);
}
}
for (char key : map.keySet()){
System.out.println(key + " <==> " + map.get(key));
}
}
}
6 斗地主
package game;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
/**
* @ClassName CardGame$
* @Description:
* @Time 2021/3/23$ 20:37$
* @Author-Email FONG_y@outlook.com
*/
public class CardGame {
public static void main(String[] args) {
HashMap<Integer, String> card = new HashMap<>();
ArrayList<Integer> arrIndex = new ArrayList<>();
String[] colors = {"♦","♣","♥","♠"};
String[] nums = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
int index = 0;
for (String num: nums){
for (String color: colors){
card.put(index,color+num);
arrIndex.add(index++);
}
}
card.put(index,"大王");
arrIndex.add(index++);
card.put(index,"小王");
arrIndex.add(index++);
//洗牌
Collections.shuffle(arrIndex);
TreeSet<Integer> player01 = new TreeSet<>();
TreeSet<Integer> player02 = new TreeSet<>();
TreeSet<Integer> player03 = new TreeSet<>();
TreeSet<Integer> lastThree = new TreeSet<>();
for (int i = 0; i < arrIndex.size(); i++) {
if (i >= arrIndex.size() - 3){
lastThree.add(arrIndex.get(i));
}else {
switch (i%3){
case 0:
player01.add(arrIndex.get(i));
break;
case 1:
player02.add(arrIndex.get(i));
break;
case 2:
player03.add(arrIndex.get(i));
break;
}
}
}
showCard("玩家1",player01,card);
showCard("玩家2",player02,card);
showCard("玩家3",player03,card);
showCard("底牌",lastThree,card);
}
private static void showCard(String name, TreeSet<Integer> treeSet, HashMap<Integer, String> card) {
System.out.print(name + ": ");
for (Integer key: treeSet){
System.out.print(card.get(key) + " ");
}
System.out.println();
System.out.println("============================================================");
}
}
7 Properties
可以把Properties 当做Map集合使用
package Properties;
import java.util.Properties;
import java.util.Set;
/**
* @ClassName Test01$
* @Description:
* @Time 2021/3/23$ 21:55$
* @Author-Email FONG_y@outlook.com
*/
public class Test01 {
public static void main(String[] args) {
Properties properties = new Properties();
properties.put("STU001","LUFFY");
properties.put("STU002","ZORO");
properties.put("STU003","USOPP");
properties.put("STU004","SANJI");
properties.put("STU005","NAMI");
properties.put("STU006","CHOPPER");
properties.put("STU007","ROBIN");
properties.put("STU008","FRANKY");
properties.put("STU009","BROOK");
Set<Object> keySet = properties.keySet();
for (Object ks:keySet){
System.out.println(ks + " <==> " + properties.get(ks));
}
}
}
使用特有方法实现键值对的存取
package Properties;
import java.util.Properties;
import java.util.Set;
/**
* @ClassName Test02$
* @Description: 特有方法实现键值对的存取
* @Time 2021/3/23$ 22:02$
* @Author-Email FONG_y@outlook.com
*/
public class Test02 {
public static void main(String[] args) {
Properties properties = new Properties();
properties.setProperty("STU001","LUFFY");
properties.setProperty("STU002","ZORO");
properties.setProperty("STU003","USOPP");
properties.setProperty("STU004","SANJI");
properties.setProperty("STU005","NAMI");
properties.setProperty("STU006","CHOPPER");
properties.setProperty("STU007","ROBIN");
properties.setProperty("STU008","FRANKY");
properties.setProperty("STU009","BROOK");
Set<String> keyset = properties.stringPropertyNames();
for (String ks:keyset){
System.out.println(ks + " <==> " + properties.getProperty(ks));
}
}
}
结合IO进行操作
package Properties;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
* @ClassName Test03$
* @Description: 结合IO流
* @Time 2021/3/23$ 22:11$
* @Author-Email FONG_y@outlook.com
*/
public class Test03 {
public static void main(String[] args) throws IOException {
//myStore();
myLoad();
}
private static void myLoad() throws IOException {
Properties properties = new Properties();
FileReader fileReader = new FileReader("./myConf.ini");
properties.load(fileReader);
fileReader.close();
System.out.println(properties);
}
private static void myStore() throws IOException {
Properties properties = new Properties();
properties.setProperty("STU001","LUFFY");
properties.setProperty("STU002","ZORO");
properties.setProperty("STU003","USOPP");
properties.setProperty("STU004","SANJI");
properties.setProperty("STU005","NAMI");
properties.setProperty("STU006","CHOPPER");
properties.setProperty("STU007","ROBIN");
properties.setProperty("STU008","FRANKY");
properties.setProperty("STU009","BROOK");
FileWriter fileWriter = new FileWriter("./myConf.ini");
properties.store(fileWriter,null);
fileWriter.close();
}
}
扫一扫
237
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
