目录
List集合代码:ArrayList与LinkedList
package com.java.jiheWork;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
/*
1.1、每个集合对象的创建(new)
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合
*/
public class ArrayListTest {
public static void main(String[] args) {
// 创建集合对象
ArrayList<String> list = new ArrayList<>();
// 添加元素
list.add("张三");
list.add("李四");
list.add("王五");
// 从集合中取出某个元素
// List集合有下标
String firstElt = list.get(0);
System.out.println(firstElt);
System.out.println(list.get(2));
System.out.println("-------------------------------");
// 遍历(下标方式)
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("-------------------------------");
// 遍历(迭代器方式,这个是通用的,所有Collection都能用)
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
System.out.println("-------------------------------");
// while循环修改为for循环
/*for(Iterator<String> it2 = list.iterator(); it2.hasNext(); ){
System.out.println("====>" + it2.next());
}*/
// 遍历(foreach方式)
for (String s : list) {
System.out.println(s);
}
System.out.println("-------------------------------");
LinkedList<Student> students = new LinkedList<Student>();
Student S1 = new Student(111,"张三");
Student S2 = new Student(122,"李四");
Student S3 = new Student(123,"王五");
students.add(S1);
students.add(S2);
students.add(S3);
Iterator<Student> it2 = students.iterator();
while (it2.hasNext()){
System.out.println(it2.next());
}
System.out.println("-------------------------------");
for (Student ST:students) {
System.out.println(ST);
}
}
}
测试结果
总结:ArrayList集合的底层是数组,可以通过下标直接查找数据,方便查找与修改。但是在增删元素时需要移动其他元素,效率较低。
LinkedList集合底层是链表,增删时不需要移动元素,方便增删。但是每次查找都要把前面的数据都过一遍,不方便查找。
HashSet 代码
package com.bjpowernode.javase.review;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;
/*
1.1、每个集合对象的创建(new)
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合
1.5、测试HashSet集合的特点:无序不可重复。
*/
public class HashSetTest {
public static void main(String[] args) {
//创建集合对象
HashSet<String> set = new HashSet<>();
//添加元素
set.add("abc");
set.add("def");
set.add("king");
set.add("abc");
System.out.println(set.size());//3
//这里我们发现set的元素个数只有3个,因为重复的元素无法添加到set集合当中
System.out.println("------------------------");
//遍历方法不能使用普通for循环,因为set集合没有下标
//遍历方法1:迭代器方式
Iterator<String> it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
System.out.println("------------------------");
//遍历方法2:foreach方式
for (String s:set) {
System.out.println(s);
}
System.out.println("------------------------");
//创建Student类集合对象
HashSet<Student> st = new HashSet<>();
//创建Student对象,其中s3与s1重复
Student s1 = new Student(111,"张三");
Student s2 = new Student(222,"李四");
Student s3 = new Student(111,"张三");
st.add(s1);
st.add(s2);
st.add(s3);
Iterator<Student> Stu = st.iterator();
while (Stu.hasNext()){
System.out.println(Stu.next());
}
System.out.println("------------------------");
for (Student stu:st) {
System.out.println(stu);
}
}
}
class Student {
int no;
String name;
public Student() {
}
public Student(int no, String name) {
this.no = no;
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return no == student.no &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(no, name);
}
}
HashSet集合的特点:底层是一个哈希表,无序不可重复。重复元素无法加入到集合中。
TreeSet代码
package com.bjpowernode.javase.review;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
/*
1.1、每个集合对象的创建(new)
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合
1.5、测试TreeSet集合中的元素是可排序的。
1.6、测试TreeSet集合中存储的类型是自定义的。
1.7、测试实现Comparable接口的方式
1.8、测试实现Comparator接口的方式(最好测试以下匿名内部类的方式)
*/
public class TreeSetTest {
public static void main(String[] args) {
// 集合的创建(可以测试以下TreeSet集合中存储String、Integer的。这些类都是SUN写好的。)
//TreeSet<Integer> ts = new TreeSet<>();
// 编写比较器可以改变规则。
TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1; // 自动拆箱
}
});
// 添加元素
ts.add(1);
ts.add(100);
ts.add(10);
ts.add(10);
ts.add(10);
ts.add(10);
ts.add(0);
// 遍历(迭代器方式)
Iterator<Integer> it = ts.iterator();
while(it.hasNext()) {
Integer i = it.next();
System.out.println(i);
}
// 遍历(foreach)
for(Integer x : ts){
System.out.println(x);
}
// TreeSet集合中存储自定义类型
TreeSet<A> atree = new TreeSet<>();
atree.add(new A(100));
atree.add(new A(200));
atree.add(new A(500));
atree.add(new A(300));
atree.add(new A(400));
atree.add(new A(1000));
// 遍历
for(A a : atree){
System.out.println(a);
}
//TreeSet<B> btree = new TreeSet<>(new BComparator());
// 匿名内部类方式。
TreeSet<B> btree = new TreeSet<>(new Comparator<B>() {
@Override
public int compare(B o1, B o2) {
return o1.i - o2.i;
}
});
btree.add(new B(500));
btree.add(new B(100));
btree.add(new B(200));
btree.add(new B(600));
btree.add(new B(300));
btree.add(new B(50));
for(B b : btree){
System.out.println(b);
}
}
}
// 第一种方式:实现Comparable接口
class A implements Comparable<A>{
int i;
public A(int i){
this.i = i;
}
@Override
public String toString() {
return "A{" +
"i=" + i +
'}';
}
@Override
public int compareTo(A o) {
//return this.i - o.i;
return o.i - this.i;
}
}
class B {
int i;
public B(int i){
this.i = i;
}
@Override
public String toString() {
return "B{" +
"i=" + i +
'}';
}
}
// 比较器
class BComparator implements Comparator<B> {
@Override
public int compare(B o1, B o2) {
return o1.i - o2.i;
}
}
HashMap代码
package com.bjpowernode.javase.review;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
1.1、每个集合对象的创建(new)
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合
*/
public class HashMapTest {
public static void main(String[] args) {
// 创建Map集合
Map<Integer, String> map = new HashMap<>();
// 添加元素
map.put(1, "zhangsan");
map.put(9, "lisi");
map.put(10, "wangwu");
map.put(2, "king");
map.put(2, "simth"); // key重复value会覆盖。
// 获取元素个数
System.out.println(map.size());
// 取key是2的元素
System.out.println(map.get(2)); // smith
// 遍历Map集合很重要,几种方式都要会。
// 第一种方式:先获取所有的key,遍历key的时候,通过key获取value
Set<Integer> keys = map.keySet();
for(Integer key : keys){
System.out.println(key + "=" + map.get(key));
}
// 第二种方式:是将Map集合转换成Set集合,Set集合中每一个元素是Node
// 这个Node节点中有key和value
Set<Map.Entry<Integer,String>> nodes = map.entrySet();
for(Map.Entry<Integer,String> node : nodes){
System.out.println(node.getKey() + "=" + node.getValue());
}
}
}
Properties代码
package com.bjpowernode.javase.review;
import java.util.Properties;
public class PropertiesTest {
public static void main(String[] args) {
// 创建对象
Properties pro = new Properties();
// 存
pro.setProperty("username", "test");
pro.setProperty("password", "test123");
// 取
String username = pro.getProperty("username");
String password = pro.getProperty("password");
System.out.println(username);
System.out.println(password);
}
}
集合继承结构图