集合框架

時間 2021-01-14 標籤集合框架

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。