定义
1.集合是用来存储数据的，也是数据的一种容器，集合只能去存储对象，每个对象就是集合中的一个元素。
数组和集合之间的区别？
数组
1.数组长度固定
2.数组只能存储同一种数据类型 ， 但是数组是能存基本数据类型和引用数据类型的
引用数据类型：引用（对象引用的地址）
引用数据类型有哪些：数组，类，接口
集合
3.集合的长度不固定，它不用声明具体的长度，集合是可以自动扩容的 ，集合只能去存储对象。
集合可以存储多种数据类型 （注意：真实项目中，一般集合中通常只存同一种数据类型）
思考：集合中是否能存储数字？ 集合中存储的数字是int 类型的包装类。
集合的语法
集合是存放在Java.util包下
共同的接口：Collection接口
map集合：
也可以去存放数据，map集合存放数据的方式是通过（键值对）的方式来存储的
键 Key 存放的一个地址
值value <key , value>
可以通过键 key快速的 查找到 具体的 value值
将123存入map 以键值对的方式存储
image.png
list集合中ArrayList语法
public class Test {
public static void main(String[] args) {
//list集合中 ArrayList的语法
//创建集合 面向接口
List list = new ArrayList();
}
}
往集合中加数据
public class Test {
public static void main(String[] args) {
//list集合中 ArrayList的语法
//创建集合 面向接口
List list = new ArrayList();
list.add("haha");
list.add(123);
list.add(12.5);
System.out.println(list);
}
}
注意：如果list集合 在不加泛型的情况下，默认的属性为object类型
泛型：如果一个集合 添加泛型 此集合就只能存储 泛型中的数据类型
泛型语法：list<数据类型>
加了泛型的集合
public class Test {
public static void main(String[] args) {
List<Integer> list2 = new ArrayList<>();
list2.add(123);
list2.add(369);
list2.add(999);
list2.add(58);
//将制定元素插入制定位置
list2.add(2 , 56);
System.out.println(list2);
}
}
上述代码如下图
image.png
集合的长度是.size
集合中add（）方法和addall（）方法的区别：
add：向集合中插入一个元素 ， 如果此元素有多条数据，那么这些数据共享一个下标
addall : 先将对象中的数据一一拿出分别存入集合当中（传入的对象中，有多少个元素就占多少个下标）
注意：addall（集合对象）的参数为集合对象
- 例题，运行查看结果
import java.util.List;
/**
* Created by ttc on 2018/6/1.
*/
public class Test {
public static void main(String[] args) {
//list集合中 ArrayList的语法
//创建集合 面向接口
List list = new ArrayList();
list.add("haha");
list.add(123);
list.add(12.5);
System.out.println(list);
List list2 = new ArrayList<>();
list2.add(123);
list2.add(369);
list2.add(999);
list2.add(58);
list2.add(2 , 56);
System.out.println(list2);
list2.addAll(list);
System.out.println(list2);
list2.add(list);
System.out.println(list2);
}
//面向实现类
// ArrayList list2 = new ArrayList();
}
list。contains（123）如果此列中包含指定元素，则返回true
此方法的参数为object类型，对象和具体的数据都可以传入
集合的遍历
用什么方式遍历集合，为什么？
for循环，需要知道 集合的长度
我们可以求出集合的长度，所以用For循环
//list2.get 访问集合中 具体元素索引值
for (int i = 0 ; i < list2.size();i++)
{
System.out.println(list2.get(i));
}
}
思考，Arraylist 自动扩容 是如何实现的 ?
list 集合 底层还是用数组实现的 ， 那么数组不是定长的么？
首先：当我们创建一个数组时，其长度 是我们手动设置的 ， 但是 在list集合中，在创建一个集合时：默认开辟一个长度为10 的一个集合空间，如果此空间存放满了， jvm会 在原来 空间基础上*1.5倍，进行自动扩容。
list集合的 特点：list 是一种 线性集合。
linkedlist ： 底层也是用数组来实现的， 它的实现方式 是通过 链表 来实现的
Arraylist 特点：访问快 ， 但是插入删除慢
linkedlist 特点：访问慢， 但是插入删除快 ， 用法与Arraylist一致
linkedlist语法
List list3 = new LinkedList();
特点：list集合是 有序可重复的集合
可重复：可以有重复的数据
序：按照存入的顺序进行排序
set集合
1.set集合是 无序 不重复 集合
无序：不按照存入顺序排序
不重复：set集合中 不允许有重复的数据
Map接口
建立国家英文简称和中文全名间的键值映射，并通过key对value进行操作，应该如何实现数据的存储和操作呢？
image.png
Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作
最常用的实现类是HashMap
image.png
Map接口常用方法
image.png
遍历List和Map
for(元素类型t 元素变量x : 数组或集合对象){
引用了x的java语句
}
练习
1.第一题 （Map）利用Map，完成下面的功能：
从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。如果该 年没有举办世界杯，则输出：没有举办世界杯。
历届世界杯冠军
届数 举办年份 举办地点 冠军
第一届 1930年 乌拉圭 乌拉圭
第二届 1934年 意大利 意大利
第三届 1938年 法国 意大利
第四届 1950年 巴西 乌拉圭
第五届 1954年 瑞士 西德
第六届 1958年 瑞典 巴西
第七届 1962年 智利 巴西
第八届 1966年 英格兰 英格兰
第九届 1970年 墨西哥 巴西
第十届 1974年 前西德 西德
第十一届 1978年 阿根廷 阿根廷
第十二届 1982年 西班牙 意大利
第十三届 1986年 墨西哥 阿根廷
第十四届 1990年 意大利 西德
第十五届 1994年 美国 巴西
第十六届 1998年 法国 法国
第十七届 2002年 韩日 巴西
第十八届 2006年 德国 意大利
第十九届 2010年 南非 西班牙
第二十届 2014年 巴西 德国
（Map）在原有世界杯Map 的基础上，增加如下功能： 读入一支球队的名字，输出该球队夺冠的年份列表。 例如，读入“巴西”，应当输出 1958 1962 1970 1994 2002 读入“荷兰”，应当输出 没有获得过世界杯
image.png
image.png
package com.company;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
/**
* Created by ttc on 2018/1/10.
*/
public class WorldCupDemo {
public static void main(String[] args) {
Map<Integer,String> year2country = new HashMap<>();
year2country.put(1930,"乌拉圭");
year2country.put(1934,"意大利");
year2country.put(1938,"意大利");
year2country.put(1950,"乌拉圭");
year2country.put(1954,"西德");
year2country.put(1958,"巴西");
year2country.put(1962,"巴西");
year2country.put(1966,"英格兰");
year2country.put(1970,"巴西");
year2country.put(1974,"西德");
year2country.put(1978,"阿根廷");
year2country.put(1982,"意大利");
year2country.put(1986,"阿根廷");
year2country.put(1990,"西德");
year2country.put(1994,"巴西");
year2country.put(1998,"法国");
year2country.put(2002,"巴西");
year2country.put(2006,"意大利");
year2country.put(2010,"西班牙");
year2country.put(2014,"德国");
Scanner scanner = new Scanner(System.in);
System.out.println("输入年份");
int year = scanner.nextInt();
if(year2country.containsKey(year))
{
System.out.println("该年的冠军是" + year2country.get(year));
}
else
{
System.out.println("该年没有举行世界杯");
}
System.out.println("请输入国家名");
String countryName = scanner.next();
//遍历map集合，考察每一个元素的value，是否和用户输入的国家一样
//如果一样，输出和value对应key
boolean bFind = false;//没有在map中找到该国家
for(Integer key : year2country.keySet())
{
String country = year2country.get(key);
if(country.equals(countryName))
{
System.out.println(key);
bFind = true;
}
}
//如果前面map遍历一遍之后，bFind的值依然是false，说明map集合中不存在用户输入的国家名
if(bFind == false)
{
System.out.println("该国家没有获得过世界杯冠军");
}
}
}
2.第二题 已知有十六支男子足球队参加2008 北京奥运会。写一个程序，把这16 支球队随机分为4 个组。采用List集合和随机数
2008 北京奥运会男足参赛国家：
科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚，日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利
提示：分配一个，删除一个
image.png
public class Maintemp {
public static void main(String[] args) {
String str = "科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚，日本，美国，中国，" +
"新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利";
String[] str1 = str.split("，");
System.out.println(str1.length);
List<String> list2team = new ArrayList<>();
for (int i = 0 ;i <str1.length;i++)
{
list2team.add(str1[i]) ;
}
System.out.println(list2team);
List<String> list2teamMin = new ArrayList<>();
Random random = new Random();
for (int j = 0 ; j < 4 ;j++)
{
for (int i = 0; i < 4; i++)
{
int suiji = random.nextInt(list2team.size());
list2teamMin.add(list2team.get(suiji));
list2team.remove(list2team.get(suiji));
}
System.out.println(list2teamMin);
list2teamMin.clear(); //清空小集合中的数据，再次添加一组新的。
}
}
}
3.第三题 有如下Student 对象，
private String name;
private int age;
private int score;
private String classNum;
其中，classNum 表示学生的班号，例如“class05”。 有如下
List List list = new ArrayList();
list.add(new Student(“Tom”, 18, 100, “class05”));
list.add(new Student(“Jerry”, 22, 70, “class04”));
list.add(new Student(“Owen”, 25, 90, “class05”));
list.add(new Student(“Jim”, 30,80 , “class05”));
list.add(new Student(“Steve”, 28, 66, “class06”));
list.add(new Student(“Kevin”, 24, 100, “class04”));
在这个list 的基础上，完成下列要求：
1） 计算所有学生的平均年龄
2） 计算各个班级的平均分
package com.maptest;
import jdk.internal.util.xml.impl.Input;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Created by ttc on 2018/6/4.
*/
public class TestStudents {
public static void main(String[] args) {
List<Student> list = new ArrayList();
list.add(new Student("Tom", 18, 100, "class05"));
list.add(new Student("Jerry", 22, 70, "class04"));
list.add(new Student("Owen", 25, 90, "class05"));
list.add(new Student("Jim", 30,80 , "class05"));
list.add(new Student("Steve", 28, 66, "class06"));
list.add(new Student("Kevin", 24, 100, "class04"));
//每个班级的学生成绩列表
Map<String,List<Integer>> mapClass2Scores = new HashMap<>();
// [class04:(70，100);class05:(100,90,80);class06:(66)];
for(Student student : list)
{
if(mapClass2Scores.containsKey(student.getClassNum()))
{
//拿到当前班级的学生成绩列表对象
List<Integer> lst = mapClass2Scores.get(student.getClassNum());
lst.add(student.getScore());
}
else//该学生所在班级，第一次加入到map中
{
List<Integer> lst = new ArrayList<>();
lst.add(student.getScore());
mapClass2Scores.put(student.getClassNum(),lst);
}
}
for(Map.Entry entry : mapClass2Scores.entrySet())
{
System.out.println("班级：" + entry.getKey());
List<Integer> listScores = (List<Integer>)entry.getValue();
int sum = 0;
for(Integer score : listScores)
{
sum += score;
}
System.out.println(sum/listScores.size());
}
int age_sum = 0;
for(Student student : list)
{
age_sum += student.getAge();
}
System.out.println(age_sum/list.size());
}
}
学生类
package com.maptest;
/**
* Created by ttc on 2018/6/4.
*/
public class Student {
private String name;
private int age;
private int score;
private String classNum;
public Student(String name, int age, int score, String classNum) {
this.name = name;
this.age = age;
this.score = score;
this.classNum = classNum;
}
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 int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public String getClassNum() {
return classNum;
}
public void setClassNum(String classNum) {
this.classNum = classNum;
}
}
5.第五题（Map）设计Account 对象如下：
private long id;
private double balance;
private String password;
要求完善设计，使得该Account 对象能够自动分配id。 给定一个List 如下：
List list = new ArrayList();
list.add(new Account(10.00, “1234”));
list.add(new Account(15.00, “5678”));
list.add(new Account(0, “1010”));
要求把List 中的内容放到一个Map 中，该Map 的键为id，值为相应的Account 对象。 最后遍历这个Map，打印所有Account 对象的id 和余额。
image.png
package com.company;
import java.util.UUID;
/**
* Created by ttc on 2018/1/11.
*/
public class Account {
private String sid;//使用UUID来生成
private double balance;
private String password;
public Account(double balance, String password)
{
this.balance = balance;
this.password = password;
//自动分配账号
this.sid = UUID.randomUUID().toString();
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
package com.company;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Created by ttc on 2018/1/11.
*/
public class TestAccount {
public static void main(String[] args) {
List<Account> accountList = new ArrayList<>();
accountList.add(new Account(100,"123"));
accountList.add(new Account(10,"456"));
accountList.add(new Account(80,"111"));
//将数据转移到map结构
Map<String,Account> accountMap = new HashMap<String,Account>();
for(Account account : accountList)
{
accountMap.put(account.getSid(),account);
}
for(Map.Entry<String,Account> entry: accountMap.entrySet())
{
System.out.println(entry.getKey() + " " + entry.getValue().getSid());
}
}
}
Account的id自增长版本
package com.company;
import java.util.UUID;
/**
* Created by ttc on 2018/1/11.
*/
public class Account {
// private String sid;//使用UUID来生成
private long sid;
private double balance;
private String password;
private static int object_count = 0;
public Account(double balance, String password)
{
this.balance = balance;
this.password = password;
//自动分配账号
//this.sid = UUID.randomUUID().toString();
//先获得当前本类已经创建了多少个对象
this.sid = Account.object_count + 1;
Account.object_count++;
}
public long getSid() {
return sid;
}
public void setSid(long sid) {
this.sid = sid;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
public static void main(String[] args) {
List<Account> accountList = new ArrayList<>();
accountList.add(new Account(100,"123"));//A
accountList.add(new Account(10,"456"));//B
accountList.add(new Account(80,"111"));
accountList.add(new Account(330,"333"));
//将数据转移到map结构
Map<Long,Account> accountMap = new HashMap<Long,Account>();
for(Account account : accountList)
{
accountMap.put(account.getSid(),account);
}
for(Map.Entry<Long,Account> entry: accountMap.entrySet())
{
System.out.println(entry.getKey() + " " + entry.getValue().getSid());
}
}
6.第六题（List）已知有一个Worker 类如下：
public class Worker
{ private int age;
private String name;
private double salary;
public Worker (){}
public Worker (String name, int age, double salary)
{ this.name = name;
this.age = age;
this.salary = salary; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public double getSalary(){ return salary; }
public void setSalary(double salary){ this.salary = salary; }
public void work(){
System.out.println(name + “ work”); } }
完成下面的要求
创建一个List，在List 中增加三个工人，基本信息如下：
姓名 年龄 工资
zhang3 18 3000
li4 25 3500
wang5 22 3200
在li4 之前插入一个工人，信息为：姓名：zhao6，年龄：24，工资3300
删除wang5 的信息
利用for 循环遍历，打印List 中所有工人的信息
利用迭代遍历，对List 中所有的工人调用work 方法。
image.png
List<Worker> workerList = new ArrayList<>();
workerList.add(new Worker("zhangsan",12,2445));
workerList.add(new Worker("lisi",32,5445));
workerList.add(new Worker("wangwu",22,7445));
Worker worker = new Worker("zhaoliu",33,5645);
workerList.add(1,worker);
workerList.remove(3);
for(int i = 0; i < workerList.size();i++)
{
System.out.println(workerList.get(i));
}
for(Worker worker1 : workerList){
worker1.work();
}
经典练习
一篇英文文章，单词间用空格分割，统计出现了哪些单词，以及每个单词出现的次数。
package com.test;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
/**
* Created by ttc on 2018/6/1.
*/
public class WordCount {
public static void main(String[] args) {
// 程序 = 数据结构 + 算法
String strTemp = "this is a dog that is a desk long long ago there is a girl";
String[] strArrays = strTemp.split(" ");
System.out.println(Arrays.toString(strArrays));
Map<String,Integer> map = new HashMap<>();
//把单词在字符串数组中保存转换为在map中保存
for(String strWord : strArrays)
{
//去map中考察，看map的key的集合中是否包含该单词
//如果不包含，往map中添加一个元素，key是单词，值是1
if(!map.containsKey(strWord))
{
map.put(strWord,1);
}
//如果包含，从map中通过该key取到对应的值（该单词之前已经出现过的次数）
//把这个值加1，在存回去
else
{
Integer count = map.get(strWord);
count++;
map.put(strWord,count);
}
System.out.println(map.get(strWord));
}
for(Map.Entry entry : map.entrySet())
{
System.out.println(entry);
}
}
}
Set
和LIst类似，主要区别是不能保存重复元素
生成100000个UUID，判断是否有重复的？
Set<String> stringSetUUID = new HashSet<>();
for(int i = 0; i < 10000000; i++)
{
UUID uuid = UUID.randomUUID();
stringSetUUID.add(uuid.toString());
}
System.out.println(stringSetUUID.size());
扑克模拟问题续
随机发出5张牌，判断牌型
image.png
image.png
image.png
image.png
image.png
单张扑克类
package com.PokerDemo;
/**
* Created by ttc on 2018/5/28.
*/
public class Card {
private int value;
private String color;
public Card(String color,int value)
{
this.value = value;
this.color = color;
}
@Override
public String toString() {
String strValue = "";
if(value == 11)
{
strValue = "J";
}
else if(value == 12)
{
strValue = "Q";
}
else if(value == 13)
{
strValue = "K";
}
else if(value == 1)
{
strValue = "A";
}
else
{
strValue = String.valueOf(value);
}
return color + strValue;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
扑克类
package com.PokerDemo;
import java.util.*;
/**
* Created by ttc on 2018/5/28.
*/
public class Poke {
private Card[] cards = new Card[52];
private String[] colors = {"红桃","黑桃","方片","草花"};
private int[] values = {1,2,3,4,5,6,7,8,9,10,11,12,13};
//初始化52个扑克对象
public Poke()
{
///红桃---下标从0到12，值是从1到13
///黑桃---下标从13到25，值是从1到13
int index = 0;
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 13; j++)
{
cards[index++] = new Card(colors[i],values[j]);
}
}
// System.out.println(Arrays.toString(cards));
// cards[0] = new Card(colors[0],values[0]);
// cards[1] = new Card(colors[0],values[1]);
// //...
// cards[13] = new Card(colors[1],values[0]);
// cards[14] = new Card(colors[1],values[1]);
// //...
// cards[26] = new Card("方片",1);
}
public void output()
{
int index = 0;
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 13; j++)
{
System.out.print(cards[index++]+" ");
}
System.out.println();
}
}
public void shuffle()
{
int index = 0;
Random random = new Random();
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 13; j++)
{
//生成一个随机下标，将随机下标带入到cards扑克数组中，得到一张随机的牌
//将当前的牌和随机出来的牌交换
int randomIndex = random.nextInt(52);
Card cardTemp = cards[index];
cards[index] = cards[randomIndex];
cards[randomIndex] = cardTemp;
}
}
}
public void judgeType(Card[] cards) {
Set<String> stringSet = new HashSet<>();
List<Integer> integerList = new ArrayList<>();
Set<Integer> integerSet = new HashSet<>();
while (true) {
for (Card card : cards) {
stringSet.add(card.getColor());
integerList.add(card.getValue());
integerSet.add(card.getValue());
}
Collections.sort(integerList);
if (stringSet.size() == 1 && (integerList.get(4) - integerList.get(0) == 4 && integerSet.size() == 5)) {
System.out.println("同花顺");
return;
} else if (stringSet.size() == 1) {
System.out.println("同花");
return;
} else if ((integerList.get(4) - integerList.get(0) == 4 && integerSet.size() == 5)) {
System.out.println("顺子");
return;
}
if (integerSet.size() == 5) {
System.out.println("杂牌");
return;
}
if (integerSet.size() == 4) {
System.out.println("一对");
return;
}
if (integerSet.size() == 2) {
// System.out.println("四带一或三带二");
// 66669 [6:4,9:1]
// 55588 [5:3,8:2]
//key是牌值，value是该牌值出现的次数
Map<Integer, Integer> map = new HashMap<>();
for (Card card : cards) {
if (map.containsKey(card.getValue())) {
int count = map.get(card.getValue());
count++;
map.put(card.getValue(), count);
} else {
map.put(card.getValue(), 1);
}
}
if (map.containsValue(4)) {
System.out.println("4带1");
return;
} else {
System.out.println("3带2");
return;
}
// map.containsValue(3)
}
if (integerSet.size() == 3) {
// System.out.println("311或221");
// 77765 [7:3,6:1,5:1]
// 88449 [8:2,4:2,9:1]
Map<Integer, Integer> map = new HashMap<>();
for (Card card : cards) {
if (map.containsKey(card.getValue())) {
int count = map.get(card.getValue());
count++;
map.put(card.getValue(), count);
} else {
map.put(card.getValue(), 1);
}
}
if (map.containsValue(3)) {
System.out.println("311");
return;
} else {
System.out.println("221");
return;
}
}
}
}
public Card[] takeOneHand()
{
Card[] cardsHand = new Card[5];
for(int i = 0; i < 5; i++)
{
cardsHand[i] = cards[i];
}
return cardsHand;
}
}
主类
package com.PokerDemo;
public class Main {
public static void main(String[] args) {
// write your code here
// Card card = new Card("黑桃",1);
// System.out.println(card);
Poke poke = new Poke();
poke.output();
poke.shuffle();
System.out.println();
poke.output();
Card[] cards = poke.takeOneHand();
poke.judgeType(cards);
}
}
