List集合
.ArrayList,LinkedList,Vector三者的相同点与不同点？(“Vector”可百度)【面试题】
共同点：
他们都实现了List接口，意味着他们具有相同的基本操作，如添加、删除、获取元素
有序性和可重复性，他们都是有序的，即插入顺序和迭代顺序相同，都允许存储重复的元素
都可以动态调整大小
不同点:
底层数据结构
ArrayList是基于数组实现的，支持快速的随机访问，但插入和删除涉及元素移动，效率较低
LinkedList底层基于双向链表实现，插入和删除只需要改变相邻节点的引用，因此效率较高，但随机访问元素需要遍历链表，因此效率较低
Vector也基于动态数组实现，但它是线程安全的，因此在多线程环境下性能更好
性能差异：
ArrayList在随机访问和遍历方面表现较好
LinkedList在插入和删除方面表现较好，尤其是列表的开头或结尾
vector由于同步，通常比ArrayList慢。+，但多线程环境中提供线程安全
扩容策略不同：
ArrayList和vector都有容器概念，当添加元素超过当前容量时，会增长自己的存储容量。ArrayList的容量大概按照大约1.5倍的速率增长，vector可以通过构造函数指定增长率，默认是2倍
LinkedList由于其基于链表的实现，不涉及容量的概念
线程安全性不同：
ArrayList和LinkedList都不是线程安全的，如果需要线程安全可以使用Collection类中的静态方法来获取线程安全的容器
vector是线程安全的，效率不是很高
3.List 接口的常用方法有哪些？(增、删、改、查、插、长度、遍历等)
add(E e):
在列表的末尾添加一个元素。
add(int index, E element):
在列表的指定位置插入一个元素。
addAll(Collection<? extends E> c):
将指定集合中的所有元素添加到列表的末尾。
addAll(int index, Collection<? extends E> c):
将指定集合中的所有元素插入到列表的指定位置。
get(int index):
返回列表中指定位置的元素。
remove(int index):
移除列表中指定位置的元素。
remove(Object o):
移除列表中首次出现的指定元素（如果存在）。
contains(Object o):
检查列表中是否包含指定的元素。
indexOf(Object o):
返回列表中首次出现指定元素的索引，如果列表不包含该元素，则返回-1。
lastIndexOf(Object o):
返回列表中最后一次出现指定元素的索引，如果列表不包含该元素，则返回-1。
isEmpty():
检查列表是否为空。
size():
返回列表中的元素数量。
iterator():
返回一个迭代器，用于遍历列表中的元素。
listIterator():
返回一个列表迭代器，它允许以任何方向遍历列表、修改列表，并获取迭代器在列表中的当前位置。
listIterator(int index):
返回一个从指定位置开始的列表迭代器。
subList(int fromIndex, int toIndex):
返回列表中指定范围的视图（从fromIndex到toIndex，不包括toIndex）。
clear():
移除列表中的所有元素。
4.如何使用Iterator和增强for循环遍历List。举例说明
//iterator
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}
//增强for
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
for (String item : list) {
System.out.println(item);
}已知有十六支男子足球队参加2008 北京奥运会。
写一个程序，把这16支球队随机分为4个组。采用List集合和随机数
2008 北京奥运会男足参赛国家：
科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚、日本，美国，中国，新西 兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class workDemo1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("科特迪瓦");
list.add("阿根廷");
list.add("澳大利亚");
list.add("塞尔维亚");
list.add("荷兰");
list.add("尼日利亚");
list.add("日本");
list.add("美国");
list.add("中国");
list.add("新西兰");
list.add("巴西");
list.add("比利时");
list.add("韩国");
list.add("喀麦隆");
list.add("洪都拉斯");
list.add("意大利");
Random r = new Random();
List<String> list1 = new ArrayList<>();
for (int i = 0; i <4; i++) {
System.out.println("这是第"+(i+1)+"组");
for (int j = 0; j <4 ; j++) {
int i1 = r.nextInt(list.size());
String s = list.get(i1);
list1.add(s);
list.remove(s);
}
System.out.println(list1);
list1.clear();
}
}
}
写一个方法reverseList，该函数能够接受一个List，然后把该List 倒序排列。 例如：
List list = new ArrayList();
list.add(“Hello”);
list.add(“World”);
list.add(“Learn”); //此时list 为Hello World Learn
reverseList(list); //调用reverseList 方法之后，list 为Learn World Hello
import java.util.ArrayList;
import java.util.List;
public class WorkDemo2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("learn");
System.out.println(list);
reverseList(list);
}
private static void reverseList(List<String> list) {
List<String> list1 = new ArrayList<>();
for (int i= list.size()-1; i>=0; i--) {
String s = list.get(i);
list1.add(s);
}
System.out.println(list1);
}
}有如下Student 对象，
private String name;
private int age;
private int score;
private String classNum;
其中，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） 计算各个班级的平均分
import java.util.ArrayList;
import java.util.List;
public class WorkDemo3 {
public static void main(String[] args) {
List<Student> 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"));
int numAge = 0;
for (Student s : list) {
numAge += s.getAge();
}
int ave1 = numAge / list.size();
System.out.println(ave1);
int sum4 = 0;
int sum5 = 0;
int sum6 = 0;
int num4 = 0;
int num5 = 0;
int num6 = 0;
for (Student s : list) {
if (s.getClassNum() == "class04") {
num4++;
sum4 += s.getScore();
}
if (s.getClassNum() == "class05") {
num5++;
sum5 += s.getScore();
}
if (s.getClassNum() == "class06") {
num6++;
sum6 += s.getScore();
}
}
System.out.println("class04班级的平均分为：" + sum4 / num4);
System.out.println("class05班级的平均分为：" + sum5 / num5);
System.out.println("class06班级的平均分为：" + sum6 / num6);
}
}
Set集合
1.请说明set接口的特点？
无序，不重复，无索引
2.set接口的实现类有哪些？他们的底层实现是什么？分别有什么特点？
set接口的实现类有Hashset和Treeset
HashSet：
底层实现原理：哈希表（散列表）
特点：
1.对集合迭代次序不做保证，存储的元素是无序的
2.允许null元素
3.集合中元素不重复
TreeSet :
底层实现原理：二叉树
特点：
1.满足set接口的特点 无序不重复
2.存满的数据可排序
3.不能存储null
其实现本质是TreeMap
请将如下4个字符串数据["aaa"，"bbb"，"ccc"，"ddd"]，依次添加到HashSet集合中，并遍历查看存储结果。（使用增强for循环遍历）
package workDemo1;
import java.util.HashSet;
public class workDemo4 {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("aaa");
set.add("bbb");
set.add("ccc");
set.add("ddd");
for (String s:set){
System.out.println(s);
}
}
}//结果
aaa
ccc
bbb
ddd进程已结束,退出代码0
在List集合内去除重复数字值，要求尽量简单（可借助其他集合！！）
package workDemo1;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class workDemo5 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("11");
list.add("10");
list.add("12");
list.add("11");
list.add("13");
list.add("10");
list.add("15");
System.out.println(list);
Set<String> set = new HashSet<>();
set.addAll(list);
for (String s:set){
}
System.out.println(set);
}
}
2019年1月份的世界编程语言排行榜从高到低依次如下： Java、C、Python、C++、Visual Basic .NET、JavaScript... 请将以上语言名称作为字符串元素，按顺序存入set集合中，并遍历查看。要求存储和遍历的顺序保持一致。
import java.util.LinkedHashSet;
public class workDemo6 {
public static void main(String[] args) {
LinkedHashSet<String> set = new LinkedHashSet<>();
set.add("Java");
set.add("C");
set.add("Python");
set.add("C++、");
set.add("Visual Basic .NET");
set.add("JavaScript");
for (String s:set){
System.out.println(s);
}
}
}现有若干图书信息（包含名称title、作者author、定价price）需要存储到set集合中，保证集合中无重复元素，并遍历查看。可以认为所有信息都相同的图书为重复数据。
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class WorkDemo {
public static void main(String[] args) {
LinkedHashSet<Book> set = new LinkedHashSet<>();
Book book1 = new Book("西游记", "吴承恩", "108");
Book book2 = new Book("水浒传","施耐庵","121");
Book book3 = new Book("红楼梦","曹雪芹","105");
Book book4 = new Book("三国演义","罗贯中","132");
Book book5 = new Book("西游记","吴承恩","108");
set.add(book1);
set.add(book2);
set.add(book3);
set.add(book4);
set.add(book5);
Iterator<Book> it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}
在某次考试中，学生的成绩信息如下（公有属性）： 姓名(String) 年龄（int） 成绩(int): Tom 20 90； Jerry 22 95； John 20 100； Lily 22 100 ；Lucy 22 90； Kevin 22 90 请分别用Comparable和Comparator两个接口对以上同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序，成绩和年龄都一样，则按照姓名的字典顺序排序。
package workDemo3;
public class Student implements Comparable<Student> {
String name;
int age;
int score;
public Student() {
}
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
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 int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
@Override
public int compareTo(Student s) {
int num=s.score-this.score;
int num1= num==0?this.age-s.age:num;
int num2= num==0?this.name.compareTo(s.name):num1;
return num2;
}
}
import java.util.TreeSet;
public class Test1 {
public static void main(String[] args) {
TreeSet<Student> set = new TreeSet<>() ;
Student stu1 = new Student("Tom",20,90);
Student stu2 = new Student("Jerry",22,90);
Student stu3 = new Student("John",20,100);
Student stu4 = new Student("Lily",22,100);
Student stu5 = new Student("Lucy",22,95);
Student stu6 = new Student("Kevin",22,90);
set.add(stu1);
set.add(stu2);
set.add(stu3);
set.add(stu4);
set.add(stu5);
set.add(stu6);
for (Student s:set){
System.out.println(s.getName()+","+s.getAge()+","+s.getScore());
}
}
} //需求：编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出
/*思路：
1.创建Set集合对象
2.创建随机数对象
3.判断集合长度是不是小于10
是：产生一个随机数添加到集合
回到3继续
4.遍历集合
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
public class SetDemo1 {
public static void main(String[] args) {
//HashSet不排序
// Set<Integer> set = new HashSet<Integer>();
//TreeSet可排序
Set<Integer> set = new TreeSet<>();
Random r = new Random();
while (set.size()<10){
int num = r.nextInt(20)+1;
set.add(num);
}
for (Integer i:set){
System.out.println(i);
}
}
}
/*
需求
键盘录入一个字符串，要求统计字符中每个字符串出现的次数
举例：键盘录入“aababcabcdabcde”在控制台输出“a(5)b(4)c(3)d(2)e(1)”
思路
1.键盘录入一个字符串
2.创建HashMap集合，键是Character,值是Integer
3.遍历字符串得到每一个字符
4.得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
如果返回值是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
如果返回值不是null，说明该字符在HashMap集合中不存在，把该值加1，然后重新存储该字符和对应的值
5.遍历HashMap集合，得到键和值，按照要求进行拼接
6.输出结果
*/
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
public class HashMapDemo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String line = sc.nextLine();
//创建HashMap集合
HashMap<Character, Integer> hm = new HashMap<Character, Integer>();
for (int i = 0; i < line.length(); i++) {
char key = line.charAt(i);
Integer value = hm.get(key);
if(value==null){
hm.put(key,1);
}else{
value++;
hm.put(key,value);
}
}
StringBuilder sb = new StringBuilder();
Set<Character> keySet = hm.keySet();
for(Character key:keySet){
Integer value = hm.get(key);
sb.append(key).append("(").append(value).append(")");
}
String s = sb.toString();
System.out.println(s);
}
}