escrito en frente
Hola a todos, soy [ Lin-Xiaobai ], un estudiante de ingeniería de software al que le gusta el conocimiento de la informática . ¡ Espero que todos puedan aprender y progresar juntos ! Soy estudiante universitario y mi nivel profesional es limitado, si encuentra algún error o deficiencia , ¡corríjame! ¡gracias a todos! ! !
Si los hermanos y hermanas están interesados en mis artículos, ¡no sean tacaños con sus manitas, den más Me gusta y síganos ! ❤❤❤ ¡ Los amo chicos! ! !
Tabla de contenido
La diferencia entre colección y colecciones
Si Lista, Conjunto, Mapa heredan de la interfaz de Colección
Indique el rendimiento de almacenamiento y las características de ArrayList, Vector, LinkedList
La diferencia entre HashMap y Hashtable
La diferencia entre ArrayList y Vector
¿Qué clases de colección conoces? método principal?
2) Enumere todos los nombres de los empleados
3) Enumere todos los nombres de los empleados y sus salarios.
4) Eliminar la información del empleado llamado "Tom"
5) Muestra el salario de Jack y agrega 1,000 yuanes a su salario (obtenido tomando valor)
Complete las siguientes operaciones según sea necesario
Complete las siguientes operaciones según sea necesario
¿Cuál es el resultado de ejecutar el siguiente código?
【Colección Charla Intensiva】
La diferencia entre colección y colecciones
Respuesta: Collection es la interfaz de nivel superior de la clase de colección, y las interfaces heredadas de ella incluyen principalmente Set y List.
Collections es una clase auxiliar para las clases de colección. Proporciona una serie de métodos estáticos para implementar operaciones como búsqueda, clasificación y seguridad de subprocesos en varias colecciones.
Los elementos en Set no se pueden repetir, entonces, ¿qué método se usa para distinguir si se repite? ¿Es == o equals()? ¿Cuál es la diferencia entre ellos?
Respuesta: Los elementos del Conjunto no se pueden repetir. Use el método equals() para juzgar si dos Conjuntos son iguales
Los métodos equals() y == determinan si los valores de referencia se refieren al mismo objeto. equals() se anula en la clase para devolver verdadero cuando el contenido y los tipos de los dos objetos separados coinciden.
Si Lista, Conjunto, Mapa heredan de la interfaz de Colección
Respuesta: lista, conjunto es, mapa no es
Dos objetos tienen el mismo valor (x.equals(y) == true), pero pueden tener diferentes códigos hash. ¿Es correcta esta oración?
Respuesta: No, tienen el mismo código hash
Indique el rendimiento de almacenamiento y las características de ArrayList, Vector, LinkedList
Respuesta: Tanto ArrayList como Vector usan matrices para almacenar datos. La cantidad de elementos en esta matriz es mayor que los datos almacenados reales para agregar e insertar elementos. Ambos permiten la indexación directa de elementos por número de serie, pero la inserción de elementos implica operaciones de memoria como como mover elementos de matriz, por lo que la indexación de datos es rápida pero la inserción de datos es lenta. Debido a que Vector usa el método sincronizado (seguridad de subprocesos), su rendimiento suele ser peor que ArrayList, mientras que LinkedList usa una lista doblemente vinculada para el almacenamiento. Indexación de datos por número de serie requiere un recorrido hacia adelante o hacia atrás, pero la inserción de datos Cuando solo necesita registrar los elementos frontal y posterior de este elemento, por lo que la velocidad de inserción es más rápida.
La diferencia entre HashMap y Hashtable
respuesta:
1. Tanto HashMap como Hashtable implementan la interfaz Map. Debido a la seguridad sin subprocesos de HashMap, puede ser más eficiente que Hashtable. El método de Hashtable es Synchronize, pero HashMap no lo es. Cuando varios subprocesos acceden a Hashtable, no es necesario sincronizar sus métodos, pero HashMap debe proporcionar sincronización externa para ello.
2. HashMap permite que se use null como clave o valor de entrada, pero Hashtable no.
3. HashMap elimina el método contains de Hashtable y lo cambia a containsvalue y containsKey. Porque el método contiene es fácilmente engañoso.
4. Hashtable hereda de la clase Dictionary y HashMap es una implementación de la interfaz Map introducida por Java1.2.
5. Los algoritmos hash/rehash utilizados por Hashtable y HashMap son aproximadamente los mismos, por lo que no habrá una gran diferencia en el rendimiento.
La diferencia entre ArrayList y Vector
Respuesta: En lo que se refiere a ArrayList y Vector, existen principalmente dos aspectos.
1. Sincronización: Vector es seguro para subprocesos, es decir, es sincrónico, mientras que ArrayList no es seguro para programas de línea, no es sincrónico.
2. Crecimiento de datos: cuando se requiere crecimiento, Vector se establece de forma predeterminada en el original 2, mientras que ArrayList es 1,5 veces el original
¿Qué clases de colección conoces? método principal?
Respuesta: Las clases de colección más utilizadas son List y Map. La implementación específica de List incluye ArrayList y Vector, que son listas de tamaño variable, más adecuadas para construir, almacenar y manipular listas de elementos de cualquier tipo de objetos. La lista es adecuada para acceder a elementos por índice numérico.
Mapa proporciona un método más general de almacenamiento de elementos. La clase de colección Map se usa para almacenar pares de elementos (llamados "claves" y "valores"), donde cada clave se asigna a un valor.
Defina una variable del tipo de interfaz Colección, haga referencia a la clase de implementación de una colección Set, agregue un solo elemento, agregue otra colección, elimine un elemento, juzgue si la colección contiene un elemento, juzgue si está vacía, borre la colección y devolver el elemento en la colección Número y otras operaciones comunes.
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test {
public static void main(String[] args) {
//引用一个Set集合实现类
Set set = new HashSet();
//添加单个元素
set.add("哈");
set.add("士");
set.add("奇");
//添加另一个Set集合
Set S = new HashSet();
//将一个集合的所有元素添加到另一个集合
S.addAll(set);
//移除指定元素
S.remove("哈");
//判断集合中是否包含另一个元素
System.out.println("集合中是否含有“哈”：" + S.contains("哈"));
//判断是否为空
System.out.println("集合是否为空：" + S.isEmpty());
//清除集合
S.clear();
//返回集合元素个数
System.out.println(S.size());
}
}Cree una clase de implementación de la interfaz Set, agregue más de 10 elementos y recorra los elementos de la colección a través de Iterator.
public static void main(String[] args) {
//创建Set接口的实现类
Set set1 = new HashSet();
//添加10个以上的元素
set1.add(22);
set1.add(2);
set1.add(55);
set1.add(78);
set1.add(5);
set1.add(15);
set1.add(7);
set1.add(30);
set1.add(9);
set1.add(70);
set1.add(11);
//通过Iterator遍历此集合元素
Iterator iterator = set1.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next() + " ");
}
}Cree una clase de implementación de la interfaz Set, agregue más de 10 elementos y recorra los elementos de la colección a través de foreach.
public class SetTest {
@Test
public void test1() {
HashSet<Object> objects = new HashSet<>();
objects.add("123");
objects.add("drtg");
objects.add("25");
objects.add("srthy");
objects.add("zxc");
objects.add("tdfh");
objects.add("453");
objects.add("SDGFrdsh");
objects.add("zx254c");
objects.add("sdGFSD");
objects.add("578585");
for (Object obj : objects) {
System.out.println(obj);
}
}
}Cree una clase de implementación de la interfaz Set, agregue más de 10 elementos y solicite la clasificación.
@Test
public void test2() {
TreeSet<Object> set1 = new TreeSet<>();
set1.add(123);
set1.add(456);
set1.add(789);
set1.add("asd");
set1.add("zxc");
set1.add("sdfg");
set1.add("qwe");
set1.add(856);
set1.add(649815);
set1.add(4563);
set1.add("dafdsgf");
set1.add(65);
set1.add(13);
set1.add(63);
for (Object obj : set1) {
System.out.println(obj);
}
}Cree una clase de automóvil, incluido el nombre, el atributo de precio, el constructor y otros métodos, cree una clase de prueba, cree una clase de implementación de la interfaz Set en el método principal, agregue más de 5 objetos de automóvil, recorra los elementos de la colección y verifique si el los elementos repetidos se filtran; si no hay filtrado, y se realiza la función de filtrado; el precio de cada automóvil se reduce en 10,000 yuanes y luego se recorre para verificar si el precio ha cambiado
auto
public class Car {
//创建Car类，包含name，price属性，构造器等方法
private String name;
private int price;
public Car() {
}
public Car(String name, int price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
@Override
public String toString() {
return "name=" + name +
" price=" + price;
}
}Clase de prueba:
public class CarTest {
public static void main(String[] args) {
//创建测试类，在main方法中创建Set接口的实现类
Set<Car> set = new TreeSet<>(new Comparator<Car>() {
@Override
public int compare(Car o1, Car o2) {
int num = o1.getName().compareTo(o2.getName());
int num1 = num == 0 ? o1.getPrice() - o2.getPrice() : num;
return num1;
}
});
//添加5个以上的Car对象
set.add(new Car("沃尔沃",250000));
set.add(new Car("大众",150000));
set.add(new Car("凯迪拉克",350000));
set.add(new Car("奥迪",550000));
set.add(new Car("雷克萨斯",950000));
set.add(new Car("雷克萨斯",950000));
//遍历集合元素，验证重复元素是否过滤了，如果没有过滤，实现过滤功能
for (Car car : set){
System.out.println(car);
}
System.out.println("------------------------------");
//把每个小车的price降10000元,再遍历，查看price是否已改变
for (Car car : set){
car.setPrice(car.getPrice()-10000);
System.out.println(car);
}
}
}Cree un objeto de instancia ArrayList, agregue más de 10 elementos, inserte un elemento en la posición 2, obtenga el elemento en la posición 5, elimine el elemento en la posición 6 y modifique el elemento en la posición 7;
@Test
public void Test3() {
ArrayList<Object> list = new ArrayList<>();
list.add(123);
list.add(123);
list.add(123);
list.add(123);
list.add(123);
list.add(123);
list.add(123);
list.add(123);
list.add(123);
list.add(123);
list.add(123);
list.add(2, 365);
System.out.println(list.get(5));
list.remove(6);
list.set(7, 666);
Iterator<Object> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}Defina una variable del tipo de interfaz Map, haga referencia a una clase de implementación, agregue un par clave-valor, determine si un determinado valor clave está contenido en la colección, obtenga un valor a través de un determinado valor clave, elimine un par clave-valor a través de un cierta clave y poner otro mapa Operaciones comunes como agregar la colección a la colección de mapas, juzgar si está vacía, borrar la colección y devolver la cantidad de elementos en la colección. Atravesar la colección de mapas de dos maneras
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
@Test
public void test4() {
// 定义一个Map接口类型的变量，引用一个实现类
HashMap<String, String> hashMap = new HashMap<String, String>();
//添加键值对
hashMap.put("123", "你好");
hashMap.put("蜂蜜", "柚子茶");
hashMap.put("Lisa", "Rose");
//判断集合中是否包含某一key值
System.out.println(hashMap.containsKey("蜂蜜"));//ture
//通过某一key值得到value值
System.out.println(hashMap.get("123"));//你好
//通过某一key删除键值对
hashMap.remove("蜂蜜");
System.out.println(hashMap); //{123=你好, Lisa=Rose}
//把另一个map集合添加到此map集合
HashMap<String, String> hashMap1 = new HashMap<String, String>();
hashMap1.putAll(hashMap);
//判断是否为空
System.out.println(hashMap.isEmpty());//false
//清除集合
hashMap.clear();
//返回集合里元素的个数
System.out.println(hashMap.size()); //0
//通过两种方法遍历上题中的map集合
//方式一
Set<String> keySet = hashMap1.keySet();
for (String key : keySet) {
String value = hashMap1.get(key);
System.out.println("key:" + key + " , " + "value:" + value);
}
System.out.println("-------------------------");
//方式二
Set<Map.Entry<String, String>> entrySet = hashMap1.entrySet();
for (Map.Entry<String, String> me : entrySet) {
String key = me.getKey();
String value = me.getValue();
System.out.println("key:" + key + " , " + "value:" + value);
}
}
Utilice la clase de implementación de la interfaz Map para completar la simulación del salario del empleado (nombre--salario):
1) Agrega algunos datos
2) Enumere todos los nombres de los empleados
3) Enumere todos los nombres de los empleados y sus salarios.
4) Eliminar la información del empleado llamado "Tom"
5) Muestra el salario de Jack y agrega 1,000 yuanes a su salario (obtenido tomando valor)
6) Aumentar los salarios de todos los empleados cuyos salarios sean inferiores a 1000 yuanes en un 20 % (realizado tomando valores)
@Test
public void test5() {
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
//1)添加几条信息
hashMap.put("Pamela", 5000);
hashMap.put("Jack", 4800);
hashMap.put("Tom", 6100);
hashMap.put("Lee", 800);
hashMap.put("Lara", 500);
//2)列出所有的员工姓名
Set<String> keySet = hashMap.keySet();
System.out.println("员工姓名：" + keySet);
//3)列出所有员工姓名及其工资
for (String key : keySet) {
//5)输出Jack的工资，并将其工资加1000元(通过取值实现)
if (hashMap.get(key).equals("Jack")) {
int value = hashMap.get(key) + 1000;
hashMap.put("Jack", value);
}
//6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)
if (hashMap.get(key) < 1000) {
double value = (hashMap.get(key) + (hashMap.get(key) * 0.2));
hashMap.put(key, (int) value);
}
int value = hashMap.get(key);
System.out.println("姓名：" + key + " , " + "工资：" + value);
}
//4)删除名叫“Tom”的员工信息
hashMap.remove("Tome");
}Encapsule una clase de noticias, incluido el título, el autor, el contenido de la noticia y la hora de publicación, el título de la noticia es el siguiente:
Noticia 1: Muchos lugares en China están envueltos en smog, la calidad del aire vuelve a ser un tema candente
Noticia 2: El DPP realizó un "Desfile de Bomberos" en Taipei
Noticia 3: Se acerca la Fiesta de la Primavera en Beijing, "fiebre de venta de casas"
Noticia 4: Se acerca la Fiesta de la Primavera en Beijing, "fiebre de venta de casas"
Complete los siguientes requisitos (50 puntos en total, 10 puntos por cada pregunta):
1) Para completar el diseño de la categoría de noticias, se requiere asignar valores a los títulos de las noticias mediante la construcción y el paso de parámetros al inicializar los objetos de la clase de noticias, e instanciar cuatro objetos, y el contenido de los títulos es como en el título.
2) Cuando se requiera imprimir el objeto noticia, imprimir directamente el título de la noticia;
3) Cuando se requiere usar el método de igualdad para comparar noticias, siempre que el título sea el mismo, se considera que es la misma noticia. Envíe los resultados de comparación de noticias 1 y noticias 2, y los resultados de comparación de noticias 3 y noticias 4.
4) Almacene el objeto de noticias en la colección HashSet y recorra la colección para imprimir el objeto de noticias;
5) Imprimir el número de noticias de la colección.
public class Journalism {
//封装一个新闻类，包含标题、作者、新闻内容和发布时间，
private String title;
private String author;
private String details;
private Date date;
public Journalism() {
}
public Journalism(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getDetails() {
return details;
}
public void setDetails(String details) {
this.details = details;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
@Override
public String toString() {
return "标题：" + title +
"\n作者：" + author +
"\n内容：" + details +
"\n发布时间：" + date ;
}
//要求使用equals方法比较新闻时，只要标题相同，就认为是同一新闻
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Journalism that = (Journalism) o;
return title != null ? title.equals(that.title) : that.title == null;
}
@Override
public int hashCode() {
return title != null ? title.hashCode() : 0;
}
}public class Test {
public static void main(String[] args) {
//创建HashSet集合对象
Set<Journalism> set = new HashSet<Journalism>();
//要求在初始化新闻类对象时 ，通过构造传参的形式对新闻标题赋值，并要求实例化四个对象，标题内容如题。
Journalism journalism1 = new Journalism("中国多地遭雾霾笼罩空气质量再成热议话题");
Journalism journalism2 = new Journalism("民进党台北举行“火大游行“");
Journalism journalism3 = new Journalism("春节临近北京“卖房热”");
Journalism journalism4 = new Journalism("春节临近北京“卖房热”");
//将新闻对象存入HashSet集合中
set.add(journalism1);
set.add(journalism2);
set.add(journalism3);
set.add(journalism4);
//要求打印新闻对象时，直接打印新闻标题；
for (Journalism journalism : set){
System.out.println(journalism);
System.out.println("------------------------");
}
//只要标题相同，就认为是同一新闻，请输出新闻一与新闻二的比较结果，新闻三与新闻四的比较结果
System.out.println("新闻一与新闻二的比较结果:"+journalism1.equals(journalism2));
System.out.println("新闻三与新闻四的比较结果:"+journalism3.equals(journalism4));
//打印集合中新闻数量
System.out.println("集合中新闻数量:"+set.size());
}
}
Complete las siguientes operaciones según sea necesario
- Genera 10 números aleatorios con valores entre 100 y 200;
- Almacene estos diez números en la colección HashSet (es posible que la longitud de la colección sea inferior a 10).
- Convierta esta colección HashSet en una colección ArrayList
- Vuelva a ordenar la colección ArrayList en orden ascendente;
- Use foreach para recorrer la colección;
@Test
public void test4() {
HashSet<Integer> hashset = new HashSet<Integer>();
Random random = new Random();
for (int i = 0; i < 10; i++) {
int j = random.nextInt(100) + 101;
hashset.add(j);
}
System.out.println(hashset);
ArrayList<Integer> list = new ArrayList<Integer>(hashset);
list.sort(Comparator.naturalOrder());
list.forEach(integer -> {
System.out.print(integer + " ");
});
}Complete las siguientes operaciones según sea necesario
1) Encapsule una clase de automóvil, incluido el nombre de cadena, los atributos de velocidad int, cree una instancia de tres objetos en la clase de prueba: c1, c2, c3, establezca respectivamente el nombre como: "Alto", "BMW", "Mercedes" y la velocidad respectivamente Establecer en: 100, 200, 300
2) Use el objeto de colección de mapas m1 para guardar estos tres objetos de automóvil como llaves y luego almacene el precio internacional del automóvil como un valor en el valor de m1. Los precios correspondientes de los tres automóviles anteriores son 10000, 500000, 2000000
3) Atraviesa las teclas de m1 e imprime el atributo de nombre
4) Calcular el precio de "BMW" en m1 a través de un método adecuado, e imprimir el resultado;
5) Después de la depreciación, todos los autos se reducen al 80% del precio original, imprima el precio de "BMW" después de la reducción del precio
@Test
public void test6() {
//在测试类中实例化三个对象：c1，c2，c3，
//分别设置name为：“奥拓”，“宝马”，“奔驰”，速度分别设置为：100,200,300
Car c1 = new Car("奥拓", 100);
Car c2 = new Car("宝马", 200);
Car c3 = new Car("奔驰", 300);
//2 ）使用Map集合对象m1将这三个汽车类对象保存成key
HashMap<Car, Integer> hashMap = new HashMap<>();
//然后将int型的汽车价钱作为值保存在m1的value中,上述三款汽车分别对应的价钱是10000,500000,2000000
hashMap.put(c1, 10000);
hashMap.put(c2, 500000);
hashMap.put(c3, 2000000);
//3 ）遍历m1的键，打印name属性
Set<Car> keySet = hashMap.keySet();
int i = 1;
for (Car car : keySet) {
System.out.print("car" + i++ + "name:" + car.getName() + " ");
}
for (Car car : keySet) {
//4 ）通过合适的方法，求出m1中“宝马”的价格，并打印结果；
if (car.getName().equals("宝马")) {
int price = hashMap.get(car);
System.out.println("\n宝马价格为：" + price);
}
//5 ）经过折旧，所有汽车都降价到原来的80%，请打印降价后“宝马”的价格
double price1 = hashMap.get(car) - (hashMap.get(car) * 0.2);
hashMap.put(car, (int) price1);
}
//请打印降价后“宝马”的价格
for (Car car : keySet) {
if (car.getName().equals("宝马")) {
int price = hashMap.get(car);
System.out.println("宝马价格为：" + price);
}
}
}¿Cuál es el resultado de ejecutar el siguiente código?
public static void main(String[] args) {
Integer[] datas = {1,2,3,4,5};
List<Integer> list = Arrays.asList(datas);
list.add(5);
System.out.println(list.size());
}Ejecutar excepción, no se permite agregar elemento
epílogo
Seguiré actualizando el artículo! Espero que todos hagan clic tres veces , su aliento es la motivación para que el autor siga actualizando
