集合框架

2019年3月24日 440次阅读 来源: 魔术师发牌问题

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<Student>
{
    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<Student> list=new ArrayList<Student>();
        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<Integer> list=new ArrayList <Integer>();
    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<n;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<String> set=new HashSet<String>();
        
            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<String> ite=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) {
        Stack<String> stack=new Stack<String>();
        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<Integer> set=new HashSet<Integer>();
        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<Poke>
{    
    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<Poke> list=new ArrayList<Poke>();
    
        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<Poke>
{

    @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<String,String> map=new HashMap<String,String>();
          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<Map.Entry<String,String>>、Set<String> get(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) {
        Map<String,String> map=new HashMap<String,String>();
        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<Stydent2> list = new ArrayList<Stydent2>();
        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<list.size();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<Integer> list = new ArrayList<Integer>();
        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<i; j++){
                p = 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<a.length-1;i++)
    {
        for(int j=0;j<a.length-i-1;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<amount.length;i++)
        {
            max+=(amount[i]*price[jj]);
            jj++;
        }
        System.out.println(max);
        int min=0;
        int gg=amount.length-1;
        for(int i=0;i<amount.length;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<K,V>


 

类型所组成的Set。

 

 

 

 

 

 

 

    原文作者：魔术师发牌问题
    原文地址: https://blog.csdn.net/qq_37997523/article/details/81837655
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞