java世界杯hashmap,集合框架

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) {

Listlist=new ArrayList();

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) {

Listlist=new ArrayList ();

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) {

Setset=new HashSet();

set.add("李易峰");

set.add("张杰");

set.add("李荣浩");

set.add("李健");

set.add("冯提莫");

set.add("李易峰");

for(String i:set)

{

System.out.println(i);

}

System.out.println("1111111111");

Iteratorite=set.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) {

Stackstack=new 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) {

Setset=new HashSet();

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

{

Listlist=new ArrayList();

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) {

Mapmap=new HashMap();

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>、Setget(key))

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) {

Mapmap=new HashMap();

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) {

Listlist = new ArrayList();

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();

Listlist = new ArrayList();

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; jp = p.next;

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。