集合框架
1.1 简答题
- List与Set的区别。
- List 有序，可重复
- Set无序，不可重复
- LinkedList与ArrayList有区别？
- 前者是通过链表实现的可以快速的进行插入和删除，后者则是通过数组实现的可以快速实现查找和随机访问
- Stack的特点是什么？pop和peek的区别?
- Stack栈，基本原理是先进后出，pop是弹出栈顶元素，peek是获得栈顶元素，前者获得并且删除栈顶元素，后者只获得不删除栈顶元素
1.2.1.设计一个Student类，该类中包括学生的姓名和成绩。创建Student类的5个对象，如下所示：
| 姓名 |
成绩 |
| 刘德华 |
85 |
| 张学友 |
100 |
| 刘杰 |
65 |
| 章子怡 |
58 |
| 周迅 |
76 |
将以上5个对象放入LinkedList中，
完成如下操作和统计：
1、输出LinkedList中的对象个数。
2、删除姓名为“刘杰”的学生信息，并输出LinkedList中现有学生信息。
3、将姓名为“刘德华”的学生成绩改为95。
4、输出成绩不及格的学生姓名
源代码：
package jihe;
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
class Student implements Comparable
{
String name;
int sore;
public Student(String name, int sore) {
super();
this.name = name;
this.sore = sore;
}
@Override
public String toString() {
return "Student [name=" + name + ", sore=" + sore + "]";
}
@Override
public int compareTo(Student o) {
return this.name.compareTo(o.name);
}
}
public class Student类 {
public static void main(String[] args) {
List
Collections.addAll(list,new Student("刘德华",85),new Student("张学友",100),new Student("刘杰",65),new Student("章子怡",58),new Student("周迅",78) );
System.out.println(list);
System.out.println(list.size());
for(int i=list.size()-1;i>=0;i--)
{
if(list.get(i).name.equals("刘杰"))
{
list.remove(i);
}
if(list.get(i).name.equals("刘德华"))
{
list.get(i).sore=95;
}
}
for(int i=list.size()-1;i>=0;i--)
if(list.get(i).sore<60)
{
System.out.println(list.get(i));
}
System.out.println(list);
}
}
1.2.2编写一个ArrayList类，用来存储1到10之间的数，打乱顺序后输出，按从小到大输出，按从大到小输出。
package jihe;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ArrayList打乱顺序输出 {
public static void main(String[] args) {
List
for(int i=0;i<10;i++)
list.add(i);
Collections.shuffle(list);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
Collections.reverse(list);
System.out.println(list);
}
}
1.2.4十五个猴子围成一圈选大王，依次1-7 循环报数，报到7 的猴子被淘汰，直到最后一只猴子成为大王。问，哪只猴子最后能成为大王？（选择一个适当的集合)
package jihe;
class JosephLoop
{ //n为环中人数，m为每次报数的人数，k为报数的起始位置0~n-1
int n,m,k;
int[] persons;
int[] seq;
JosephLoop(int n, int k, int m){
this.n = n;
this.m = m;
this.k = k;
persons = new int[n];
seq = new int[n];
}
public void showSeq(){
for (int x:seq )
{
System.out.print(x+" ");
}
}
//杀死则把数组persons的相应位置的值赋值为1，活这时候值默认为0
public void calcLoop(){
for(int j=0;j
int index=k;
for (int i=1; i<=m ; index++)
{
if (persons[index%n]==0)//如果此人还活着则i++
{
i++;
}
}
persons[(index-1)%n] = 1;//表示相应位置的人被杀死
seq[j] = (index-1)%n;//输出数组相应位置的人
k = (index)%n;//控制起始位置
}
}
}
class 约瑟环
{
public static void main(String[] args)
{
JosephLoop jose = new JosephLoop(15,0,7); //n,k,m
jose.calcLoop();
jose.showSeq();
}
}
1.2.5.定义一个Set，向Set中存储5个人名，其中有两个是重复的，输出Set集合的数据，通过for each,和Iterator两种方法。
package jihe;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Set输出 {
public static void main(String[] args) {
Set
set.add("李易峰");
set.add("张杰");
set.add("李荣浩");
set.add("李健");
set.add("冯提莫");
set.add("李易峰");
for(String i:set)
{
System.out.println(i);
}
System.out.println("1111111111");
Iterator
while(ite.hasNext())
{
System.out.println(ite.next());
}
}
}
1.2.6：编写一个例子，测试Stack的push和pop方法
package jihe;
import java.util.Stack;
public class 栈的输入和输出 {
public static void main(String[] args) {
Stack
stack.push("李易峰");
stack.push("张杰");
stack.push("李荣浩");
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}
1.2.7编写一个22选5的彩票选号程序。每次选出不同的五组号码，并输出到控制台中。
package jihe;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
public class Work22选五 {
public static void main(String[] args) {
Set
Random random=new Random();
for(int i=1;set.size()<5;i++)
{
set.add(random.nextInt(22)+1);
}
System.out.println(set);
}
}
1.2.8 * 编写一个扑克类(每张扑克有花色和数值，例如红心A,草花10),将52张扑克牌放到集合中(自己去选择集合类)
编写3个方法
方法1.将集合中的所有扑克重新洗牌,并将扑克输出(打印出来即可)
方法2.将集合中的所有扑克排序(按方块3~方块2,草花3~草花2, 红心3~红心2, 黑桃3~黑桃2的顺序排序)
方法3：比较两张扑克牌的大小，如果版面的值相等，则按（黑桃->红心->草花->方块）的顺序进行排列
测试以上方法
package jihe;
import java.util.*;
class Poke implements Comparable
{
private final static String [] STYLES= {"方块","草花","红心","黑桃"};
private final static String [] VALUES= {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
int style;//面值
int values; //花色
public Poke(int style, int values) {
this.style = style;
this.values = values;
}
@Override
public String toString() {
return STYLES[style] + VALUES[values];
}
@Override
public int compareTo(Poke o) {
return style==o.style?this.values-o.values:this.style-o.style;
}
}
class PokeCard
{
List
public PokeCard()
{
//初始化52张牌
for(int i=0;i<52;i++)
{
list.add(new Poke(i%4,i/4));
}
}
//打乱顺序
public void shuffle()
{
Collections.shuffle(list);
}
//排序1
public void sort()
{
Collections.sort(list);
}
//排序2
public void sort2()
{
Collections.sort(this.list,new MycomParator6());
}
//输出
public void show()
{
for(Poke i:list)
System.out.println(i);
}
}
class MycomParator6 implements Comparator
{
@Override
public int compare(Poke o1, Poke o2)
{
return o1.values==o2.values?o1.style-o2.style:o1.values-o2.values;
}
}
public class poke6 {
public static void main(String[] args) {
PokeCard card=new PokeCard();
card.show();
System.out.println("11111111111111111111111");
card.shuffle();
card.show();
System.out.println("22222222222222");
card.sort();
card.show();
System.out.println("333333333333333");
card.sort2();
card.show();
}
}
1.2.9 *自已实现一个动态数组类，为这个类添加如下方法
class DynamicArray{
public void add(Object obj); //追加一个新元素
public void add(int index,Object obj); //在某个位置插入一个元素
public void remove(int index); //删除指定位置的元素
public Object get(int index); //根据索引，获得某个位置的元素
public void set(int index,Object obj); //修改指定位置的元素
public boolean contain(Object obj);//是否包含某个元素
}
1.2.11（Map）利用Map，完成下面的功能：
1.从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。如果该
年没有举办世界杯，则输出：没有举办世界杯。
2. 读入一支球队的名字，输出该球队夺冠的年份列表。
例如，读入“巴西”，应当输出
1958 1962 1970 1994 2002
读入“荷兰”，应当输出
没有获得过世界杯
附：世界杯冠军以及对应的夺冠年份，请参考本章附录。
附录
1. 截止到2009 年为止，历届世界杯冠军
package jihe;
import java.security.KeyStore.Entry;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
public class 世界杯 {
//根据Value取Key
public static void getKeyByValue(Map map, Object value) {
String keys="";
Iterator it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (java.util.Map.Entry) it.next();
Object obj = entry.getValue();
if (obj != null && obj.equals(value)) {
keys=(String) entry.getKey();
System.out.println(keys);
}
}
}
public static void main(String[] args) {
Map
map.put("2006", "意大利");
map.put("2002", "巴西");
map.put("1998", "法国");
map.put("1994", "巴西");
map.put("1990", "德国");
map.put("1986", "阿根廷");
map.put("1982", "意大利");
map.put("1978", "阿根廷");
map.put("1974", "德国");
map.put("1970", "巴西");
map.put("1966", "英格兰");
map.put("1962", "巴西");
map.put("1958", "巴西");
map.put("1954", "德国");
map.put("1950", "乌拉圭");
map.put("1938", "意大利");
map.put("1934", "意大利");
map.put("1930", "乌拉圭");
System.out.println("请输入一个年份：");
Scanner scanner=new Scanner(System.in);
String s=map.get(scanner.next());
if(s.equals(null)==false)
{
System.out.println("该年的冠军是："+s);
}
else
{
System.out.println("没有举办世界杯！！！");
}
System.out.println("请输入相应的国家：");
String s1=scanner.next();
if(map.containsValue(s1))
{
getKeyByValue(map,s1);
}
else
{
System.out.println("没有获得过世界杯！！！");
}
}
}
1．2.12. （Map）已知某学校的教学课程内容安排如下：
完成下列要求：
1） 使用一个Map，以老师的名字作为键，以老师教授的课程名作为值，表示上述
课程安排。
2） 增加了一位新老师Allen 教JDBC
3） Lucy 改为教CoreJava put方法
4） 遍历Map，输出所有的老师及老师教授的课程(Set
5） *利用Map，输出所有教JSP 的老师
package jihe;
import java.util.*;
public class 教学课程 {
public static void getKeyByValue(Map map, Object value) {
String keys="";
Iterator it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (java.util.Map.Entry) it.next();
Object obj = entry.getValue();
if (obj != null && obj.equals(value)) {
keys=(String) entry.getKey();
System.out.println(keys);
}
}
}
public static void main(String[] args) {
Map
map.put("Tom", "CoreJava");
map.put("John", "Oracle");
map.put("Susan", "Oracle");
map.put("Jerry", "JDBC");
map.put("Jim", "Unix");
map.put("Kevin", "JSP");
map.put("Luck", "JSP");
System.out.println(map.entrySet());
map.put("Allen", "JDBC");
map.put("Lucy", "Corejava");
System.out.println(map.entrySet());
System.out.println("输出所有教JSP 的老师为：");
getKeyByValue(map,"JSP");
}
}
1.2.13**（综合）有如下Student 对象
其中，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） 计算各个班级的平均分
class05:3个学生，总分：，平均分：
class04:3个学生，总分：，平均分：
class06:3个学生，总分：，平均分：
package jihe;
import java.util.*;
class Stydent2
{
String name;
int age;
double score;
String classNum;
public Stydent2(String name, int age, double score, String classNum) {
super();
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 double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public String getClassNum() {
return classNum;
}
public void setClassNum(String classNum) {
this.classNum = classNum;
}
@Override
public String toString() {
return "Stydent2 [name=" + name + ", age=" + age + ", score=" + score + ", classNum=" + classNum + "]";
}
}
public class student对象 {
public static void main(String[] args) {
List
list.add(new Stydent2("Tom", 18,100,"class05"));
list.add(new Stydent2("Jerry", 22, 70, "class04"));
list.add(new Stydent2("Owen", 25, 90, "class05"));
list.add(new Stydent2("Jim", 30,80 , "class05"));
list.add(new Stydent2("Steve", 28, 66, "class06"));
list.add(new Stydent2("Kevin", 24, 100, "class04"));
int pjage=0;
int pjscore[]=new int[3];
int count[]=new int[3];
for(int i=0;i
pjage+=list.get(i).getAge();
if(list.get(i).getClassNum().equals("class04"))
{
pjscore[0]+=list.get(i).getScore();
count[0]++;
}
if(list.get(i).getClassNum().equals("class05"))
{
pjscore[1]+=list.get(i).getScore();
count[1]++;
}
if(list.get(i).getClassNum().equals("class06"))
{
pjscore[2]+=list.get(i).getScore();
count[2]++;
}
}
System.out.println("平均年龄为："+pjage/list.size());
System.out.println("class04平均分数为："+pjscore[0]/count[0]+"该班共有学生人数为："+count[0]+"人");
System.out.println("class05平均分数为："+pjscore[1]/count[1]+"该班共有学生人数为："+count[1]+"人");
System.out.println("class06平均分数为："+pjscore[2]/count[2]+"该班共有学生人数为："+count[2]+"人");
}
}
1.2.14 *微信红包的实现
封装一个微信红包类，主要的功能有
红包中存有钱，多少个人分；每个分到的钱数，及获收红包的时间；
主要的功能有
打开红包；（如果打开红包的人数没有达到上限，则可以打开，并随机获得金额）
查看红包分配信息；
设置截止日期；（如果超过最大金额，则再打时提示过期）
例如红包中的钱数为500;分成10个包
在1到499之间产生9个不重复的值，并排序即可;
package jihe;
import java.util.*;
public class 微信红包 {
public static void main(String[] args) {
Random r = new Random();
List
int[] s = new int[9];
for (int i = 0; i < 9; i++) {
s[i] = r.nextInt(499) + 1;
}
Arrays.sort(s);
list.add(s[0]);
for (int i = 1; i < 9; i++) {
list.add(s[i] - s[i - 1]);
}
list.add(500 - s[8]);
while (list.size() != 0) {
System.out.println("恭喜你抢到了" + list.get(0));
list.remove(0);
}
Date date=new Date();
System.out.println("红包已过期");
System.out.println(date);
}
}
1.2.15魔术师发牌问题
魔术师手中有A、2、3……J、Q、K十三张黑桃扑克牌。在表演魔术前，魔术师已经将他们按照一定的顺序叠放好（有花色的一面朝下）。魔术表演过程为：一开始，魔术师数1，然后把最上面的那张牌翻过来，是黑桃A；然后将其放到桌面上；第二次,魔术师数1、2；将第一张牌放到这些牌的最下面，将第二张牌翻转过来，正好是黑桃2；第三次，魔术师数1、2、3；将第1、2张牌依次放到这些牌的最下面，将第三张牌翻过来正好是黑桃3；……直到将所有的牌都翻出来为止。问原来牌的顺序是如何的。
package jihe;
/**
**问题名称：魔术师发牌问题
*问题描述：魔术师手里一共有13张牌，全是黑桃，1~13.
*********魔术师需要实现一个魔术：这是十三张牌全部放在桌面上（正面向下），
********第一次摸出第一张，是1，翻过来放在桌面上。
******第二次摸出从上往下数第二张，是2，翻过来 放在桌面上，（第一张放在最下面去，等会儿再摸），
*****第三次摸出从上往下数第三张，是3，翻过来放在桌面上，（第一张和第二张 放在最下面去，等会儿再摸）
*** 以此类推 最后一张就是13
*
* 方法：
* 1、创建一个长度为13的单向循环链表，链表中值全部存0
* 2、遍历链表进行修改值
* @author wyl
*
*/
public class 魔术师 {
private Node head; //定义链表的头结点
/**
* 创建链表中的Node类
*/
class Node{
private Integer data;
private Node next;
public Node(){
}
public Node(Integer data){
this(data, null);
}
public Node(Integer data, Node next) {
this.data = data;
this.next = next;
}
public Integer getData() {
return data;
}
public void setData(Integer data) {
this.data = data;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
/**
* 构造函数中直接初始化长度为13的循环链表
* 第一个节点的值默认为1
*/
public 魔术师(){
head = new Node(1);
Node p = head ;
int i = 1;
while(p.next == null && i < 13){
Node newNode = new Node(0);
p.next = newNode;
p = p.next;
i++;
}
p.next = head; //构建循环链表
}
//打印循环链表
public void print(){
Node p = head;
int i = 0;
while(i++<13){
System.out.print(p.data + "、");
p = p.next ;
}
}
//循环修改节点的值
public void magic(){
int i = 2; //从2开始存数字到13
Node p = head; //指针p指向head,用来控制每次指针移动的下一个位置
for(;i<=13;i++){
for(int j = 0; j
if(p.data != 0){
j--;
}
}
p.data = i;
}
}
public static void main(String[] args) {
魔术师 magicCord = new 魔术师();
magicCord.print();
magicCord.magic();
System.out.println();
magicCord.print();
}
}
1.2.16 价格标签丢失（京东笔试题）
超市有商品若干，每个商品都对应一个价格标签，标签已经写好价格，但还没放置到对应的商品上，如果某一顾客已经购买了n种商品，每种商品都有对应的数量，求出最少花费和最多花费;
提示，已经写好的价格标签可存在数组中，每种商品的数量也可存在数据中；
例如：int[] price={78,2,54,12,90,100,23,5,12};
int[] amount={4,7,1,9,4};
package jihe;
import java.util.Collection;
import java.util.Collections;
public class 京东笔试题 {
static void sort(int [] a)
{
for(int i=0;i
for(int j=0;j
if(a[j]>a[j+1])
{
int c=a[j];
a[j]=a[j+1];
a[j+1]=c;
}
}
}
}
public static void main(String[] args) {
int[] price={78,2,54,12,90,100,23,5,12};
int[] amount={4,7,1,9,4};
sort(price);
for(int i:price)
System.out.print(i+" ");
System.out.println();
sort(amount);
for(int i:amount)
System.out.print(i+" ");
System.out.println();
int max=0;
int jj=price.length-amount.length;
for(int i=0;i
max+=(amount[i]*price[jj]);
jj++;
}
System.out.println(max);
int min=0;
int gg=amount.length-1;
for(int i=0;i
min+=(amount[gg]*price[i]);
gg--;
}
System.out.println(min);
}
}
1.2.10. （Map）关于下列Map 接口中常见的方法（填空）
put 方法表示放入一个键值对，如果键已存在则则替换，如果键不存在则
则添加。
remove 方法接受_1__个参数，表示_如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
get 方法表示__key_____对应的_______values_________，get 方法的参数表示__key_，返回值表示_values_。
要想获得Map 中所有的键，应该使用方法__keyset________，该方法返回值类型为__set___。
要想获得Map 中所有的值，应该使用方法___values________，该方法返回值类型为___collection___。
要想获得Map 中所有的键值对的集合，应该使用方法____entryset_______，该方法返回一个
___Map.Entry
类型所组成的Set。