給定一段JAVA代碼如下：要打印出list中存儲的內容，以下語句正確的是（ B ）
ArrayList list = new ArrayList( )
list.add(“a”)
list.add(“b”)
Iterator it = list.iterator( )
A.while(it. Next( ) ) system.out.println(it.next( ) )
B.for(int i=0; i<list.size( ) i++) system.out.println(list.get(i))
C.while(list.hasNext( ) ) system.out.println(list.next( ) )
D.for(int i=0; i<list.size( ) i++) system.out.println(it(i))
下面代碼運行結果正確的是（C ）
import java.util.*;
public class TestListSet{
public static void main(String args[]){
List list = new ArrayList();
list.add(“Hello”);
list.add(“Learn”);
list.add(“Hello”);
list.add(“Welcome”);
Set set = new HashSet();
set.addAll(list);
System.out.println(set.size());
}
}
A.編譯不通過 B.編譯通過，運行時異常
C.編譯運行都正常，//輸出HashSet中不能放重復值 D.編譯運行都正常，輸出4
在java中，（ B）接口位於集合框架的頂層
A.Map B.Collection C.Set D.List
在JAVA中，以下（ C ）類的對象以鍵-值的方式存儲對象
A.java.util.List B.java.util.ArrayList C.java.util.HashMap D.java.util.LinkedList
在JAVA中ArrayList類實現了可變大小的數組，便於遍歷元素和隨機訪問元素，已知獲得了ArrayList類的對象bookTypeList，則下列語句中能夠實現判斷列表中是否存在字符串“小說”的是（C ）
A.bookTypeList.add("小說"); B.bookTypeList.get("小說");
C.bookTypeList.contains("小說"); D.bookTypeList.remove("小說");
下面敘述哪些是正確的？（ABC ）
A.java中的集合類（如Vector）可以用來存儲任何類型的對象，且大小可以自動調整。但需要事先知道所存儲對象的類型，才能正常使用
B.在java中，可以用異常（Exception）來拋出一些並非錯誤的消息，但這樣比直接從函數返回一個結果要花費更大的系統開銷。
C.java接口包含函數聲明和常量聲明。
D.java中，子類不可以訪問父類的私有成員和受保護的成員
在JAVA中，LinkedList類和ArrayList類同屬於集合框架類，下列（ABC ）選項中的方法是LinkedList類ArrayList類都有的
A.add(Object o) B.add(int index，Object o) C.remove(Object o) D.removeLast()
請分析下面程序編譯並運行的結果
class MyNumberException<T> extends Exception{
public MyNumberException(String message){
super(message);
}
}
public class GenericsTest{
public static void main(String[] args){
int num=1;
try{
if(num<10){
throw new MyNumberException("數字小於10");
}
}catch(MyNumberException e){
System.out.println(e);
}catch(Exception e){
System.out.println(e);
}
}
}
解析：在Java中泛型類繼承Throwable及其子類都是不合法的，所以上面的程序編譯無法通過
已知：
public class ListTest{
public static void main(String[] args){
LinkedList<String> link=new LinkedList<String>();
link.add("1");
link.add("2");
link.add("3");
link.addFirst("F");
link.addLast("L");
for(int i=0;i<link.size();i++){
link.remove(i);
}
System.out.println(link);
}
}
程序運行結果：[1,3]
解析：添加完元素後，集合中的元素順序為[F,1,2,3,L]，各個元素對應索引位置為0,1,2,3,4 執行第一次循環，i=0，刪除F，集合變為[1,2,3,L]，各個元素對應的索引位置為0,1,2,3 執行第二次循環：i=1，刪除2，集合變為[1,3,L]，各個元素對應的索引位置為0,1,2 執行第三次循環：i=2,刪除L，集合變為[1,3]，各個元素對應的索引位置為0,1 所以程序結束，結果為[1,3]
利用Map，完成下面的功能：
從命令行讀入一個字符串，表示一個年份，輸出該年的世界杯冠軍是哪支球隊。如果該年沒有舉辦世界杯，則輸出：沒有舉辦世界杯。
附：世界杯冠軍以及對應的奪冠年份
public class Bk {
public static void main(String[] args) {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String year=null;
try {
year=br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
Map<String,String> map=new HashMap<String, String>();
map.put("2002", "巴西");
map.put("2006", "意大利");
map.put("2010","南非");
if(map.containsKey(year)){
System.out.println(map.get(year));
}
else{
System.out.println("這一年沒有承辦世界杯！");
}
}
}
完善下列代碼，實現把List 中的內容放到一個Map 中，該Map 的鍵為id值為相應的Account 對象。最後遍歷這個Map，打印所有Account 對象的id 和余額
public class Test{
public static void main(String[] args) {
List list=new ArrayList();
list.add(new Account(10.00,"1234"));
list.add(new Account(15.00,"5678"));
list.add(new Account(0.0,"1010"));
Map map=new HashMap();
for(int i=0;i<list.size();i++){
Account account=(Account)list.get(i);
map.put(account.getId(), account);
}
Set<Map.Entry<Long,Object>> set=map.entrySet();
for(Map.Entry<Long, Object> obj:set){
Account acc=(Account)obj.getValue();
System.out.println(obj.getKey()+"/"+acc.getBalance());
}
}
}
class Account{
private long id;
private double balance;
private String password;
public Account(){}
public Account(double balance,String password){
this.id=new Random().nextLong();
this.balance=balance;
this.password=password;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
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;
}
}
寫出下面程序的輸出結果
import java.util.*;
class MyClass{
int value;
public MyClass(){}
public MyClass(int value){
this.value = value;
}
public String toString(){
return value;
}
}
public class TestList{
public static void main(String args[]){
MyClass mc1 = new MyClass(10);
MyClass mc2 = new MyClass(20);
MyClass mc3 = new MyClass(30);
List list = new ArrayList();
list.add(mc1);
list.add(mc2);
list.add(mc3);
MyClass mc4 = (MyClass) list.get(1);
//MyClass mc4=(MyClass)mc2;
mc4.value = 50;
for(int i = 0; i<list.size(); i++){
System.out.println(list.get(i));
}
}
}
程序運行結果：
10
50
30
使用HashMap完成學生信息的管理功能，主要功能包括：添加學生數據、打印學生名單、刪除學生數據、按學號查詢學生信息四個功能。並實現持久化保存
//Java序列化是指把Java對象轉換為字節序列的過程；而Java反序列化是指把字節序列恢復為Java對象的過程
public class Student implements Serializable{
private static final long serialVersionUID = 1L;
private String sno;
private String name;
private String gender;
private int age;
public Student(String sno,String name,String gender,int age){
super();
this.sno=sno;
this.name=name;
this.gender=gender;
this.age=age;
}
public String getSno() {
return sno;
}
public void setSno(String sno) {
this.sno = sno;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return sno+"\t"+name+"\t"+gender+"\t"+age;
}
}
public interface DAOStudent {
public boolean saveAll(HashMap<String, Student> students);
public HashMap<String, Student> getAll();
}
public class ImplDAOStudent implements DAOStudent{
@Override
public HashMap<String, Student> getAll() {
HashMap<String,Student> hm=new HashMap<String, Student>();
File file=new File("student.txt");
ObjectInputStream ois=null;
try{
ois=new ObjectInputStream(new FileInputStream(file));
if(file.length()!=0){
hm=(HashMap<String, Student>)ois.readObject();
}
ois.close();
}catch(Exception e){
e.printStackTrace();
}
return hm;
}
@Override
public boolean saveAll(HashMap<String, Student> students){
File file=new File("student.txt");
long l=file.length();
ObjectOutputStream oos=null;
try{
oos=new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(students);
oos.close();
}catch(Exception e){
e.printStackTrace();
}
if(file.length()>l){
return true;
}
else {
return false;
}
}
}
public class StudentControl {
private static DAOStudent DAOstu=new ImplDAOStudent();
private static HashMap<String,Student> students;
public static StudentControl st=new StudentControl();
static{
students=DAOstu.getAll();
}
private StudentControl(){}
public static StudentControl getInstance(){
return st;
}
public boolean addStudent(Student s){
if(!students.containsKey(s.getSno())){
students.put(s.getSno(), s);
return true;
}else{
return false;
}
}
public ArrayList<Student> getAll(){
ArrayList<Student> al=new ArrayList<Student>();
Set<Map.Entry<String, Student>> set=students.entrySet();
Iterator<Map.Entry<String,Student>> it=set.iterator();
while(it.hasNext()){
Map.Entry<String,Student> entry= it.next();
Student stu=entry.getValue();
al.add(stu);
}
return al;
}
public boolean deleteStudent(String sno){
if(students.containsKey(sno)){
students.remove(sno);
return true;
}else{
return false;
}
}
public Student queryStudentBySno(String sno){
if(students.containsKey(sno)){
return students.get(sno);
}else
return null;
}
public boolean exitSystem(){
return DAOstu.saveAll(students);
}
}
public class ViewStudent {
public void menu(){
System.out.println("*********************");
System.out.println("請選擇需要的功能：");
System.out.println("1.添加學生數據");
System.out.println("2.打印學生名單");
System.out.println("3.刪除學生數據");
System.out.println("4.打印對應學號的學生數據");
System.out.println("0.退出系統");
System.out.println("**********************");
}
}
public class ManageStudent{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
StudentControl sco=StudentControl.getInstance();
while(true){
new ViewStudent().menu();
int count=sc.nextInt();
switch(count){
case 1: System.out.println("請輸入學生信息：");
System.out.print("姓名:");
String name=sc.next();
System.out.print("學號:");
String sno=sc.next();
System.out.print("性別:");
String gender=sc.next();
System.out.print("年齡:");
int age=sc.nextInt();
Student student=new Student(sno,name,gender,age);
if(sco.addStudent(student)){
System.out.println("操作成功");
}else{
System.out.println("操作失敗");
}
break;
case 2:
System.out.println("學號\t\t姓名\t性別\t年齡");
ArrayList<Student> list=sco.getAll();
Iterator<Student> it=list.iterator();
while(it.hasNext()){
Student stu=it.next();
System.out.println(stu.toString());
}
break;
case 3:System.out.println("請輸入需要刪除的學生的學號：");
String string=sc.next();
if(sco.deleteStudent(string)){
System.out.println("操作成功");
}else{
System.out.println("操作失敗");
}
break;
case 4:System.out.println("輸入你要查找的學號：");
String str=sc.next();
Student stu=sco.queryStudentBySno(str);
System.out.println("學號\t\t姓名\t性別\t年齡");
System.out.println(stu.toString());
break;
case 0:
sco.exitSystem();
System.exit(0);
default:System.out.println("輸入有誤，請重新輸入");
}
}
}
}
輸入學生信息，按學生成績排序
public class Stu{
private String name;
private int score;
public Stu(){}
public Stu(String name,int score){
this.name=name;
this.score=score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public String toString(){
return name+":"+score;
}
}
public class CompareScore implements Comparator<Stu>{
public boolean equals(Object obj){
return super.equals(obj);
}
@Override
public int compare(Stu s1, Stu s2) {
if(s1.getScore()>s2.getScore()){
return -1;
}else if(s1.getScore()<s2.getScore()){
return 1;
}else{
return s2.getName().compareTo(s1.getName());
}
}
}
public class DemoTreeSet {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
TreeSet<Stu> ts=new TreeSet<Stu>(new CompareScore());
while(true){
System.out.print("給出你的選擇(1.添加信息、2.降序輸出、3.退出程序)：");
int num=sc.nextInt();
switch(num){
case 1:
System.out.print("輸入學生的姓名：");
String name=sc.next();
System.out.print("輸入學生的成績：");
int score=sc.nextInt();
ts.add(new Stu(name,score));
break;
case 2:System.out.println(ts);
break;
case 0:System.exit(0);
default:System.out.println("輸入有誤，請重新輸入");
}
}
}
}
使用泛型得到數組的最大和最小值
interface MaxOrMin<T extends Comparable<T>>{
T min(T[] t);
T max(T[] t);
}
public class TextMinOrMax {
public static void main(String[] args) {
Integer[] in=new Integer[]{43,52,66,71,39,33};
Character[] ch=new Character[]{'f','v','d','t','z'};
ComparableElement<Integer> ce1=new ComparableElement<Integer>();
System.out.println("int數組的最大值："+ce1.max(in)+",最小值："+ce1.min(in));
ComparableElement<Character> ce2=new ComparableElement<Character>();
System.out.println("char數組的最大值："+ce2.max(ch)+",最小值："+ce2.min(ch));
}
}
class ComparableElement<T extends Comparable<T>> implements MaxOrMin<T>{
T max;
T min;
@Override
public T max(T[] t) {
max=t[0];
for(int i=0;i<t.length;i++){
if(max.compareTo(t[i])<0){
max=t[i];
}
}
return max;
}
@Override
public T min(T[] t) {
min=t[0];
for(int i=0;i<t.length;i++){
if(min.compareTo(t[i])>0){
min=t[i];
}
}
return min;
}
}
Iterator與ListIterator有什麼區別？
Iterator：只能正向遍歷集合，適用於獲取移除元素。ListIerator：繼承Iterator，可以雙向列表的遍歷，同樣支持元素的修改。
Collection和Collections的區別
答：Collection：是java.util包中的接口，是集合類的基本接口，主要的子接口有List和Set
Collections：是java.util包中的類，是針對集合的一個實用工具類，它包含了對各種集合的搜索、排序和線程安全等一系列的靜態方法。
ArrayList與Vector的異同
答：相同點：ArrayList和Vector都是List的子類，都是有序的集合，可以存儲相同的元素，相當於動態數組，他們都可以按索引位置取得指定的元素。
區別：（1）出現的時間：Vector是在JDK1.0就已存在，而ArrayList到了JDK1.2才推出。
（2）同步性：Vector是線程安全的，也就是說它的方法之間是線程同步的，而ArrayList是線程不安全的，它的方法之間是線程不同步的。在程序設計中，如果是只有一個線程會訪問到集合，最好選擇使用ArrayList,因為他不考慮線程安全，效率會高些；如果多個線程會訪問到集合，最好選擇使用Vector，因為不需要開發人員自己編寫線程安全的代碼。
（3）數據增長：ArrayList與Vector都存在初始的容量大小，且都為10，當存儲進集合裡的元素的個數超過了容量時，就需要增加ArrayList與Vector的存儲空間。每次要增加存儲空間時，不是只增加一個存儲單元，而是增加多個存儲單元。這就要求每次增加的存儲單元的個數在內存空間利用與線程效率之間要取得一定的平衡。Vector默認增長為原來一倍，而ArrayList的增長策略在文檔中沒有明確規定（從源代碼看到的是增長為原來的一半）
（4）輸出方式：Vector可以使用Iterator、foreach和Enumeration方式輸出，而ArrayList只能使用Iterator、foreach方式輸出
簡述HashMap與Hashtable的異同
答：相同點：HashMap與Hashtable都是Map接口的實現類，而HashMap是Hashtable的輕量級實現（非線程安全的實現）。兩者都是用key-value方式獲取數據。
區別：（1）出現的時間：Hashtable在JDK1.0時出現，屬於舊的操作類，而HashMap是在JDK1.2時推出的類，屬於較新的操作類
（2）同步性：Hashtable是線程安全的，也就是說是同步的，性能相對較低，而HashMap是線程不安全的，不是同步的，性能相對較高。
（3）值：Hashtable不允許存放null值和null鍵，而HashMap允許存在一個null鍵和多個null值
(4)HashMap沒法保證映射的順序一直不變，但是作為HashMap的子類LinkedHashMap，如果想要預知的順序迭代（默認按照插入順序），你可以很輕易的置換為HashMap，如果使用Hashtable就沒那麼容易了。
(5)迭代HashMap采用快速失敗機制，而Hashtable不是，所以這是設計的考慮點
ArrayList中的淺拷貝與深拷貝
淺拷貝:被復制對象的所有變量都含有與原來的對象相同的值，而所有的對其他對象的引用仍然指向原來的對象。換言之，淺復制僅僅復制所考慮的對象，而不復制它所引用的對象。
深拷貝：被復制對象的所有變量都含有與原來的對象相同的值，除去那些引用其他對象的變量。那些引用其他對象的變量將指向被復制過的新對象，而不再是原有的那些被引用的對象。換言之，深復制把要復制的對象所引用的對象都復制了一遍.（eg: 1、直接賦值（字符串外都屬於淺拷貝） 2、使用構造函數（深拷貝） 3、使用clone()方法（深拷貝） )
ArrayList中為何加transient關鍵字？
transient是Java語言的關鍵字，變量修飾符，如果用transient聲明一個實例變量，當對象存儲時，它的值不需要維持。這裡的對象存儲是指，Java的serialization提供的一種持久化對象實例的機制。當一個對象被序列化的時候，transient型變量的值不包括在序列化的表示中，然而非transient型的變量是被包括進去的。使用情況是：當持久化對象時，可能有一個特殊的對象數據成員，我們不想用serialization機制來保存它。為了在一個特定對象的一個域上關閉serialization，可以在這個域前加上關鍵字transient。
Java中的泛型是什麼 ? 使用泛型的好處是什麼?
泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。這種參數類型可以用在類、接口和方法的創建中，分別稱為泛型類、泛型接口、泛型方法。 泛型的好處是在編譯的時候檢查類型安全，並且所有的強制轉換都是自動和隱式的，提高代碼的重用率。
Java的泛型是如何工作的 ? 什麼是類型擦除？
Java中的泛型基本上都是在編譯器這個層次來實現的。在生成的Java字節碼中是不包含泛型中的類型信息的。使用泛型的時候加上的類型參數，會在編譯器在編譯的時候去掉。這個過程就稱為類型擦除。
請舉例說明static和泛型的沖突所在
泛型類確定T的類型實在運行是時期，而static在編譯時期已經存在。
