Java集合和泛型练习及面试题——博客园：师妹开讲啦
給定一段JAVA代碼如下：要打印出list中存儲的內(nèi)容，以下語句正確的是（?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))??
下面代碼運行結(jié)果正確的是（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類實現(xiàn)了可變大小的數(shù)組，便于遍歷元素和隨機訪問元素，已知獲得了ArrayList類的對象bookTypeList，則下列語句中能夠?qū)崿F(xiàn)判斷列表中是否存在字符串“小說”的是（C?）
A.bookTypeList.add("小說");? B.bookTypeList.get("小說");?
C.bookTypeList.contains("小說");? ?? D.bookTypeList.remove("小說");?
下面敘述哪些是正確的？（ABC??）
A.java中的集合類（如Vector）可以用來存儲任何類型的對象，且大小可以自動調(diào)整。但需要事先知道所存儲對象的類型，才能正常使用
B.在java中，可以用異常（Exception）來拋出一些并非錯誤的消息，但這樣比直接從函數(shù)返回一個結(jié)果要花費更大的系統(tǒng)開銷。
C.java接口包含函數(shù)聲明和常量聲明。
D.java中，子類不可以訪問父類的私有成員和受保護的成員
在JAVA中，LinkedList類和ArrayList類同屬于集合框架類，下列（ABC?）選項中的方法是LinkedList類ArrayList類都有的
A.add(Object?o) B.add(int?index，Object?o) C.remove(Object?o)? D.removeLast()
請分析下面程序編譯并運行的結(jié)果
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("數(shù)字小于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);
}
}
程序運行結(jié)果：[1,3]
解析：添加完元素后，集合中的元素順序為[F,1,2,3,L]，各個元素對應索引位置為0,1,2,3,4 執(zhí)行第一次循環(huán)，i=0，刪除F，集合變?yōu)閇1,2,3,L]，各個元素對應的索引位置為0,1,2,3 ? 執(zhí)行第二次循環(huán)：i=1，刪除2，集合變?yōu)閇1,3,L]，各個元素對應的索引位置為0,1,2 ?執(zhí)行第三次循環(huán)：i=2,刪除L，集合變?yōu)閇1,3]，各個元素對應的索引位置為0,1 所以程序結(jié)束，結(jié)果為[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("這一年沒有承辦世界杯！");??
}?
}???
}
完善下列代碼，實現(xiàn)把List?中的內(nèi)容放到一個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;
}
}
寫出下面程序的輸出結(jié)果
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));?
}?
}?
}
程序運行結(jié)果：
10
50
30
使用HashMap完成學生信息的管理功能，主要功能包括：添加學生數(shù)據(jù)、打印學生名單、刪除學生數(shù)據(jù)、按學號查詢學生信息四個功能。并實現(xiàn)持久化保存--博客園：師妹開講啦
//Java序列化是指把Java對象轉(zhuǎn)換為字節(jié)序列的過程；而Java反序列化是指把字節(jié)序列恢復為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.添加學生數(shù)據(jù)");
System.out.println("2.打印學生名單");
System.out.println("3.刪除學生數(shù)據(jù)");
System.out.println("4.打印對應學號的學生數(shù)據(jù)");
System.out.println("0.退出系統(tǒng)");
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("輸入有誤，請重新輸入");
}
}
}
}
?
使用泛型得到數(shù)組的最大和最小值
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數(shù)組的最大值："+ce1.max(in)+",最小值："+ce1.min(in));
ComparableElement<Character> ce2=new ComparableElement<Character>();
System.out.println("char數(shù)組的最大值："+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有什么區(qū)別？
Iterator：只能正向遍歷集合，適用于獲取移除元素。ListIerator：繼承Iterator，可以雙向列表的遍歷，同樣支持元素的修改。
Collection和Collections的區(qū)別
答：Collection：是java.util包中的接口，是集合類的基本接口，主要的子接口有List和Set
Collections：是java.util包中的類，是針對集合的一個實用工具類，它包含了對各種集合的搜索、排序和線程安全等一系列的靜態(tài)方法。
ArrayList與Vector的異同--博客園：師妹開講啦
答：相同點：ArrayList和Vector都是List的子類，都是有序的集合，可以存儲相同的元素，相當于動態(tài)數(shù)組，他們都可以按索引位置取得指定的元素。
區(qū)別：（1）出現(xiàn)的時間：Vector是在JDK1.0就已存在，而ArrayList到了JDK1.2才推出。
（2）同步性：Vector是線程安全的，也就是說它的方法之間是線程同步的，而ArrayList是線程不安全的，它的方法之間是線程不同步的。在程序設計中，如果是只有一個線程會訪問到集合，最好選擇使用ArrayList,因為他不考慮線程安全，效率會高些；如果多個線程會訪問到集合，最好選擇使用Vector，因為不需要開發(fā)人員自己編寫線程安全的代碼。
（3）數(shù)據(jù)增長：ArrayList與Vector都存在初始的容量大小，且都為10，當存儲進集合里的元素的個數(shù)超過了容量時，就需要增加ArrayList與Vector的存儲空間。每次要增加存儲空間時，不是只增加一個存儲單元，而是增加多個存儲單元。這就要求每次增加的存儲單元的個數(shù)在內(nèi)存空間利用與線程效率之間要取得一定的平衡。Vector默認增長為原來一倍，而ArrayList的增長策略在文檔中沒有明確規(guī)定（從源代碼看到的是增長為原來的一半）
（4）輸出方式：Vector可以使用Iterator、foreach和Enumeration方式輸出，而ArrayList只能使用Iterator、foreach方式輸出
簡述HashMap與Hashtable的異同--博客園：師妹開講啦
答：相同點：HashMap與Hashtable都是Map接口的實現(xiàn)類，而HashMap是Hashtable的輕量級實現(xiàn)（非線程安全的實現(xiàn)）。兩者都是用key-value方式獲取數(shù)據(jù)。
區(qū)別：（1）出現(xiàn)的時間：Hashtable在JDK1.0時出現(xiàn)，屬于舊的操作類，而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、使用構(gòu)造函數(shù)（深拷貝）??3、使用clone()方法（深拷貝）??)
ArrayList中為何加transient關(guān)鍵字？
?? transient是Java語言的關(guān)鍵字，變量修飾符，如果用transient聲明一個實例變量，當對象存儲時，它的值不需要維持。這里的對象存儲是指，Java的serialization提供的一種持久化對象實例的機制。當一個對象被序列化的時候，transient型變量的值不包括在序列化的表示中，然而非transient型的變量是被包括進去的。使用情況是：當持久化對象時，可能有一個特殊的對象數(shù)據(jù)成員，我們不想用serialization機制來保存它。為了在一個特定對象的一個域上關(guān)閉serialization，可以在這個域前加上關(guān)鍵字transient。
Java中的泛型是什么 ? 使用泛型的好處是什么?
泛型的本質(zhì)是參數(shù)化類型，也就是說所操作的數(shù)據(jù)類型被指定為一個參數(shù)。這種參數(shù)類型可以用在類、接口和方法的創(chuàng)建中，分別稱為泛型類、泛型接口、泛型方法。 泛型的好處是在編譯的時候檢查類型安全，并且所有的強制轉(zhuǎn)換都是自動和隱式的，提高代碼的重用率。
Java的泛型是如何工作的 ? 什么是類型擦除？
Java中的泛型基本上都是在編譯器這個層次來實現(xiàn)的。在生成的Java字節(jié)碼中是不包含泛型中的類型信息的。使用泛型的時候加上的類型參數(shù)，會在編譯器在編譯的時候去掉。這個過程就稱為類型擦除。
請舉例說明static和泛型的沖突所在
泛型類確定T的類型實在運行是時期，而static在編譯時期已經(jīng)存在。
?
?
轉(zhuǎn)載于:https://www.cnblogs.com/xiaoshimei/p/6230735.html
總結(jié)
以上是生活随笔為你收集整理的Java集合和泛型练习及面试题——博客园：师妹开讲啦的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java对接微信公众号
- 下一篇： 关于如何参与到开源项目中《How To