1. Object
java.lang.Object类是Java语言中类层次结构的根类,也就是说任何一个类都是该类的直接或者间 接子类。
/**
* 重写比较两个对象的内容
*
* @param obj
* @return
*/
@Override
public boolean equals(Object obj) {
// 默认-比较两个对象的地址
//return super.equals(obj);
// 重写比较内容
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if
Studect studect = (Studect) o;
if (id != studect.id) return false;
return name != null ? name.equals(studect.name) : studect.name == null;
}
/**
* equals保存一致 相等应保持hashCode相同 不等hashCode不相同
*
* @return
*/
@Override
public int hashCode() {
// 默认
//return super.hashCode();
// 重写
int result = id;
result = 31 * result + (name != null ? name.hashCode() : 0);
return result;
}
/**
* 为了返回有意义的内容
* 重写toString
*
* @return
*/
@Override
public String toString() {
return "Studect{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
2. 包装类
包装类 | 对应的基本类型 |
---|---|
java.lang.Byte | byte |
java.lang.Short | short |
java.lang.Integer | int |
java.lang.Long | long |
java.lang.Float | float |
java.lang.Double | double |
java.lang.Boolean | boolean |
java.lang.Character | char |
- 基本数据类型转换为对应包装类的方式 调用包装类的构造方法或静态方法即可
- 获取包装类对象中基本数据类型变量数值的方式 调用包装类中的xxxValue方法即可
- 字符串转换为基本数据类型的方式 调用包装类中的parseXxx方法即可
Integer
常量类型和名称 | 功能介绍 |
---|---|
public static final int MAX_VALUE | 表示int类型可以描述的最大值,即2^31-1 |
public static final int MIN_VALUE | 表示int类型可以描述的最小值,即-2^31 |
public static final int SIZE | 表示int类型采用二进制补码形式的位数 |
public static final int BYTES | 表示int类型所占的字节个数 |
public static final Class TYPE | 表示int类型的Class实例 |
// 构造方法使用-过时
Integer it1 = new Integer(123);
System.out.println("it1=" + it1);
Integer it2 = new Integer("456");
System.out.println("it2=" + it2);
// 建议使用--装箱
Integer it3 = Integer.valueOf(123);
System.out.println("it3=" + it3);
Integer it4 = Integer.valueOf("456");
System.out.println("it4=" + it4);
// 拆箱
int ia = it4.intValue();
System.out.println("ia=" + ia);
// java5开始新特性 自动装箱自动拆箱
Integer it5 = 125;
int tb = it5;
// 自动装箱池 -128-127
Integer it6 = 125;
Integer it7 = 125;
Integer it8 = new Integer(125);
Integer it9 = new Integer(125);
System.out.println(it6 == it7); // 比较地址 true
System.out.println(it6.equals(it7)); // 比较内容 true
System.out.println(it8 == it9); // 比较地址 false
System.out.println(it8.equals(it7)); // 比较内容 true
// 不在自动装箱池中
Integer it10 = 129;
Integer it11 = 129;
Integer it12 = new Integer(129);
Integer it13 = new Integer(129);
System.out.println(it10 == it11); // 比较地址 false
System.out.println(it10.equals(it11)); // 比较内容 true
System.out.println(it12 == it13); // 比较地址 false
System.out.println(it12.equals(it13)); // 比较内容 true
// 实现静态方法调用
int ic = Integer.parseInt("22222"); // 数字字符串
System.out.println("string to int :"+ic);
System.out.println("十进制:"+Integer.toString(200));
System.out.println("二进制:"+Integer.toBinaryString(200));
System.out.println("八进制:"+Integer.toOctalString(200));
System.out.println("十六进制:"+Integer.toHexString(200));
- int 和 Integer对比
- int 是原始类型的数据 占用的空间更少
- Integer 是int的包装类,有一个 int 类型的字段存储数据,并且提供了基本操作
- 在 Java 5 中新增了静态工厂方法 valueOf,在调用它的时候会利用一个缓存机制, Integer值默认缓存是 -128 到 127 之间
2. Double
常量类型和名称 | 功能介绍 |
---|---|
public static final int SIZE | 表示double类型的二进制位数 |
public static final int BYTES | 表示double类型的字节个数 |
public static final Class TYPE | 表示double类型的Class实例 |
// java5之前装箱/拆箱
Double db1 = Double.valueOf(3.13);
System.out.println("db1 = "+db1);
double d1 = db1.doubleValue();
System.out.println("d1 = "+d1);
// java5之后自动装箱/拆箱
Double db2 = 3.14;
System.out.println("db2 = "+db2);
double d2 = db2;
System.out.println("d2 = "+d2);
// 实现静态方法和成员方法的调用
double d3 = Double.parseDouble("13.14");
System.out.println(d3);
System.out.println("db2是否非数字"+db2.isNaN());
Double db3 = Double.valueOf(0/0.0);
System.out.println("db3是否非数字"+db3.isNaN());
3. Boolean
常量类型和名称 | 功能介绍 |
---|---|
public static final Boolean FALSE | 对应基值为false的对象 |
public static final Boolean TRUE | 对应基值为true的对象 |
public static final Class TYPE | 表示boolean类型的Class实例 |
// java5之前装箱/拆箱
Boolean bo1 = Boolean.valueOf(true);
System.out.println("bo1=" + bo1);
boolean b1 = bo1.booleanValue();
System.out.println("b1=" + b1);
// 自动装箱/拆箱
Boolean bo2 = false;
boolean b2 = bo2;
System.out.println("b2=" + b2);
// string to boolean
boolean b3 = Boolean.parseBoolean("true");
System.out.println("b3=" + b3);
boolean b4 = Boolean.parseBoolean("xxx");
System.out.println("b3=" + b4);
4. Character
常量类型和名称 | 功能介绍 |
---|---|
public static final int SIZE | 表示char类型的二进制位数 |
public static final int BYTES | 表示char类型的字节个数 |
public static final Class TYPE | 表示char类型的Class实例 |
// java5之前装箱/拆箱
Character ca1 = Character.valueOf('a');
char c1 = ca1.charValue();
System.out.println("ca1=" + ca1);
System.out.println("c1=" + c1);
// 自动装箱/拆箱
Character ca2 = 'a';
char c2 = ca2;
System.out.println("ca2=" + ca2);
System.out.println("c2=" + c2);
// 字符判断+转换
System.out.println(Character.isUpperCase('B'));
System.out.println(Character.isLowerCase('b'));
System.out.println(Character.isDigit('1'));
System.out.println(Character.toUpperCase('a'));
System.out.println(Character.toLowerCase('A'));
3. Math
方法声明 | 功能介绍 |
---|---|
static int max(int a, int b) | 返回两个参数中的最大值 |
static int min(int a, int b) | 返回两个参数中的最小值 |
static double pow(double a, double b) | 返回第一个参数的幂 |
static int abs(int a) | 返回参数指定数值的绝对值 |
static long round(double a) | 返回参数四舍五入的结果 |
static double sqrt(double a) | 返回参数的平方根 |
static double random() | 返回0.0到1.0的随机数 |
4. BigDecimal
由于float类型和double类型在运算时可能会有误差,若希望实现精确运算则借助 java.math.BigDecimal类型加以描述。
BigDecimal bd1 = new BigDecimal("5.2");
BigDecimal bd2 = new BigDecimal("1.3");
// 精确运算
System.out.println("+=" + bd1.add(bd2));
System.out.println("-=" + bd1.subtract(bd2));
System.out.println("*=" + bd1.multiply(bd2));
System.out.println("/=" + bd1.divide(bd2));
// 注意事项
BigDecimal bd3 = new BigDecimal("10");
BigDecimal bd4 = new BigDecimal("3");
//System.out.println("/=" + bd3.divide(bd4)); // ArithmeticException 无限循环小数 期望精确值
System.out.println("/=" + bd3.divide(bd4, RoundingMode.HALF_UP)); // 四舍五入
5. BigInteger
若希望表示比long类型范围还大的整数数据,则需要借助java.math.BigInteger类型描述。
BigInteger bi1 = new BigInteger("2000000");
BigInteger bi2 = new BigInteger("21");
System.out.println("+ = " + bi1.add(bi2));
System.out.println("- = " + bi1.subtract(bi2));
System.out.println("* = " + bi1.multiply(bi2));
System.out.println("/ = " + bi1.divide(bi2));
System.out.println("% = " + bi1.remainder(bi2));
System.out.println("/ % = " + bi1.divideAndRemainder(bi2)[0].toString() + bi1.divideAndRemainder(bi2)[1].toString());
6. String
String 类是 final 类, 不可以被继承
常量池
由于String类型描述的字符串内容是常量不可改变,因此Java虚拟机将首次出现的字符串放入常量 池中,若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对 象,从而提高了性能。
// 字符串常量池
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2);// 比较地址 true
// 构造方法
// 1
String str4 = new String();
System.out.println(str4); //""
// 2
byte[] b = {97, 98, 99, 100, 101};
String str5 = new String(b, 1, 3);
System.out.println(str5);
String str6 = new String(b);
System.out.println(str6);
// 3
char[] c = {'a', 'b', 'c', 'd', 'e'};
String str7 = new String(c, 1, 3);
System.out.println(str7);
String str8 = new String(c);
System.out.println(str8);
// 4
String str9 = new String("abc");//根据参数指定的字符串内容来构造对象,新创建对象为参数对象的副本
System.out.println(str9);
// 注意事项1
String str10 = "hello"; // 1个对象 常量池
String str11 = new String("hello"); // 2个对象 1."abc" 常量池 2. new 在堆区
// 注意事项2
String str12 = "hello";
String str13 = new String("hello");
/**
* str10 == str12 true 常量池
* str10 == str13 false
* str13 == str11 false
* equals() 相等
*/
String str14 = "he" + "llo"; // str14 == str10 常量优化
String str15 = "he";
String str16 = str15 + "llo"; // str16 == str10 false 变量没有优化
// 将当前字符串内容转换为byte数组并返回
byte[] barr = str.getBytes();
for (int i = 0; i < barr.length; i++) {
System.out.println(barr[i]);
}
// 用于将当前字符串内容转换为char数组并返回
char[] carr = str.toCharArray();
for (int i = 0; i < carr.length; i++) {
System.out.println(carr[i]);
}
// 判断字符串是否为空
if (str1.isEmpty()) {
// int length() 返回字符串字符序列的长度
for (int i = 0; i < str1.length(); i++) {
// 方法charAt用于返回字符串指定位置的字符
System.out.println(str1.charAt(i));
}
}
- 将"12345"to 12345的方法
String str17 = "12345";
// 1
int a = Integer.parseInt(str17);
// 2
// '1'-'0' =1
int ib = 0;
for (int i = 0; i < str17.length(); i++) {
ib = ib * 10 + (str17.charAt(i) - '0');
}
System.out.println(ib);
// int compareTo(String anotherString) 用于比较调用对象和参数对象的大小关系
// int compareToIgnoreCase(String str) 不考虑大小写,也就是'a'和'A'是相等的关系
/*
* this.charAt(k)-anotherString.charAt(k)
* this.length()-anotherString.length()
*/
String s1 = "Hello";
System.out.println(s1.compareTo("hello")); // 'H' - 'h' = -32
System.out.println(s1.compareTo("Hello")); // 0
System.out.println(s1.compareTo("HELLO")); // 'e' - 'E' = 32
System.out.println(s1.compareTo("Hello word")); // length 5- 10 = -5
System.out.println(s1.compareToIgnoreCase("hello")); //0
System.out.println(s1.compareToIgnoreCase("Hello")); //0
System.out.println(s1.compareToIgnoreCase("HELLO")); //0
String s1 = " Hello word ";
// 用于实现字符串的拼接
System.out.println(s1.concat(" word")); // s1 + " word"
// 用于判断当前字符串是否包含参数指定的内容
System.out.println(s1.contains("h")); // false
System.out.println(s1.contains("H")); // true
// 返回字符串的小写形式
System.out.println(s1.toLowerCase());// hello word
// 返回字符串的大写形式
System.out.println(s1.toUpperCase());// HELLO WORD
// 返回去掉前导和后继空白的字符串
System.out.println(s1.trim()); //Hello word
// 判断字符串是否以参数字符串开头
System.out.println(s1.startsWith(" "));
// 从指定位置开始是否以参数字符串开头
System.out.println(s1.startsWith("He", 1));
// 判断字符串是否以参数字符串结尾
System.out.println(s1.endsWith(" "));
System.out.println(s1);// Hello word
String s1 = " Hello word ";
System.out.println("Hello".equals(s1));
System.out.println(" hello word ".equalsIgnoreCase(s1));
String s1 = " Hello word ";
System.out.println(s1.indexOf('a')); // -1
System.out.println(s1.indexOf('o')); // 5
System.out.println(s1.indexOf("o")); // 5
System.out.println(s1.indexOf('o',6)); // 8
System.out.println(s1.indexOf("o",6));// 8
System.out.println(s1.lastIndexOf('o')); // 8
System.out.println(s1.lastIndexOf("o")); // 8
System.out.println(s1.lastIndexOf('o',7)); // 5
System.out.println(s1.lastIndexOf("o",7));// 5
// [1,)
System.out.println(s1.substring(1)); //Hello word
System.out.println(s1.substring(1,6));//Hello
// int to String
// 1
String s = ""+123;
//2
String s3 = String.valueOf(123);
7. 正则
正则表达式 | 说明 |
---|---|
[abc] | 可以出现a、b、c中任意一个字符 |
[^abc] | 可以出现任何字符,除了a、b、c的任意字符 |
[a-z] | 可以出现a、b、c、……、z中的任意一个字符 |
[a-zA-Z0-9] | 可以出现az、AZ、0~9中任意一个字符 |
正则表达式 | 说明 |
---|---|
. | 任意一个字符(通常不包含换行符) |
\d | 任意一个数字字符,相当于[0-9] |
\D | 任意一个非数字字符 |
\s | 空白字符,相当于[\t\n\x0B\f\r] |
\S | 非空白字符 |
\w | 任意一个单词字符,相当于[a-zA-Z_0-9] |
\W | 任意一个非单词字符 |
正则表达式 | 说明 |
---|---|
. | 任意一个字符(通常不包含换行符) |
\d | 任意一个数字字符,相当于[0-9] |
\D | 任意一个非数字字符 |
\s | 空白字符,相当于[\t\n\x0B\f\r] |
\S | 非空白字符 |
\w | 任意一个单词字符,相当于[a-zA-Z_0-9] |
\W | 任意一个非单词字符 |
方法名称 | 方法说明 |
---|---|
boolean matches(String regex) | 判断当前正在调用的字符串是否匹配参数指定的正则表达式规 则 |
方法名称 | 方法说明 |
---|---|
String[] split(String regex) | 参数regex为正则表达式,以regex所表示的字符串为分隔 符,将字符串拆分成字符串数组 |
String replace(char oldChar, char newChar) | 使用参数newChar替换此字符串中出现的所有参数 oldChar |
String replaceFirst(String regex, String replacement) | 替换此字符串匹配给定的正则表达式的第一个子字符串 |
String replaceAll(String regex, String replacement) | 将字符串中匹配正则表达式regex的字符串替换成 replacement |
可变字符串
- String类描述的字符串内容是个常量不可改变
- java.lang.StringBuilder类和java.lang.StringBuffffer类来描述字符序列可以改变的字符串
- StringBuffffer类是从jdk1.0开始存在,属于线程安全的类,因此效率比较低。
- StringBuilder类是从jdk1.5开始存在,属于非线程安全的类,效率比较高。
StringBuilder
/**
* 构造方法
*/
// 无参构造方法 容量16
StringBuilder s1 = new StringBuilder();
// 参数指定容量
StringBuilder s2 = new StringBuilder(10);
// 指定字符串 容量 = 16 + 字符串长度
StringBuilder s3 = new StringBuilder("test");
/**
* 成员方法
* 作为参数传递的话,方法内部String不会改变其值,StringBuffer和StringBuilder会改变其值。
* StringBuilder的很多方法的返回值均为StringBuilder类型。这些方法的返回语句均为:return this。
* 这样设计的目的在于可以连续调用。
*/
//1. int capacity() 返回容量
System.out.println(s1.capacity()); // 16
System.out.println(s2.capacity()); // 10
System.out.println(s3.capacity()); // 20
// 2. int length() 用于返回字符串的长度,也就是字符的个数
System.out.println(s1.length()); // 0
System.out.println(s2.length()); // 0
System.out.println(s3.length()); // 4
//3. StringBuilder insert(int offset, String str) 插入字符串并返回调用对象的引用,就是自己。
StringBuilder s4 = s3.insert(2, "abc");
System.out.println(s3); // teabcst
System.out.println(s4); // teabcst
//4. StringBuilder append(String str) 追加字符串
s3.append("append");
System.out.println(s3); // teabcstappend
// 自动扩容 (oldCapacity << 1) + 2
s2.append("1234567890abcd");
System.out.println(s2.capacity()); // 22 10*2+2
System.out.println(s2.length()); // 14
//5. StringBuilder deleteCharAt(int index) 将当前字符串中下标为index位置的单个字符删除
s2.append("abc");
// s2.deleteCharAt(3); // StringIndexOutOfBoundsException
s2.deleteCharAt(1);
System.out.println(s2);
//6. StringBuilder delete(int start,int end) 删除字符串 [start,end)
System.out.println(s3); // teabcstappend
s3.delete(2, 4);
System.out.println(s3); // tecstappend
//7 StringBuilder replace(int start,int end,String str) 替换字符串
s3.replace(0, 5, "replace");
System.out.println(s3); //replaceappend
//8 StringBuilder reverse() 字符串反转
s3.reverse();
System.out.println(s3); //dneppaecalper
Java8之前的日期相关类(熟悉)
System
/**
* System
* static long currentTimeMillis()
* 返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差
*/
System.out.println(System.currentTimeMillis());
Date
// Date() 使用无参的方式构造对象,也就是当前系统时间
Date d = new Date();
// Date(long date) 根据参数指定毫秒数构造对象, 参数为距离1970年1月1日0时0分0秒的毫秒数
Date d1 = new Date(System.currentTimeMillis());
// long getTime() 获取调用对象距离1970年1月1日0时0分0秒的毫秒数
System.out.println(d.getTime());
System.out.println(d1.getTime());
// void setTime(long time) 设置调用对象为距离基准时间time毫秒的时间点
d.setTime(10);
d1.setTime(100);
SimpleDateFormat
java.text.SimpleDateFormat
// SimpleDateFormat() 使用无参方式构造对象
Date date = new Date();
SimpleDateFormat s = new SimpleDateFormat();
// SimpleDateFormat(String pattern) 根据参数指定的模式来构造对象,模式主要有: y-年 M-月 d-日 H-时 m-分 s-秒
SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// final String format(Date date) 用于将日期类型转换为文本类型
String r = s.format(date);
String r1 = s1.format(date);
System.out.println(r); //2020/8/22 下午4:29
System.out.println(r1); //2020-08-22 16:29:31
// Date parse(String source) 用于将文本类型转换为日期类型
Date date1 = s1.parse("2020-08-22 16:29:15");
Calendar
- java.util.Calender类主要用于描述特定的瞬间,取代Date类中的过时方法实现全球化。
- 该类是个抽象类,因此不能实例化对象,其具体子类针对不同国家的日历系统,其中应用最广泛的是GregorianCalendar(格里高利历),对应世界上绝大多数国家/地区使用的标准日历系统。
// static Calendar getInstance() 用于获取Calendar类型的引用
// 返回的不是Calendar类型的对象 而是子类的对象
// 多态使用
Calendar c = Calendar.getInstance();
// void set(int year, int month, int date, int hourOfDay, int minute, int second) 用于设置年月日时分秒信息
// 0代表一月份
c.set(2020, 8, 20, 12, 30, 0);
// Date getTime() 用于将Calendar类型转换为Date类型
Date date2 = c.getTime();
SimpleDateFormat s2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(s2.format(date2)); // 2020-09-20 12:30:00
// void set(int field, int value) 设置指定字段的数值
c.set(Calendar.DATE, 5);
System.out.println(s2.format(c.getTime())); // 2020-09-05 12:30:00
// void add(int field, int amount) 向指定字段增加数值
c.add(Calendar.MONTH, 1);
System.out.println(s2.format(c.getTime())); //2020-10-05 12:30:00
问题
- Date类中的年份是从1900开始的,而月份都从0开始。
- 格式化只对Date类有用,对Calendar类则不能使用。
- 非线程安全等。
Java8中的日期相关类
java.time包:该包日期/时间API的基础包。
java.time.chrono包:该包提供对不同日历系统的访问。
java.time.format包:该包能够格式化和解析日期时间对象。
java.time.temporal包:该包包含底层框架和扩展特性。
java.time.zone包:该包支持不同时区以及相关规则的类。
now
/**
* LocalDate
* static LocalDate now()
* 在默认时区中从系统时钟获取当前日期
*/
System.out.println(LocalDate.now()); //2020-08-22
/**
* LocalTime
* static LocalTime now() 从默认时区的系统时间中获取当前时间
* static LocalTime now(ZoneId zone) 获取指定时区的当前时间
*/
System.out.println(LocalTime.now()); // 16:59:18.369296
/**
* LocalDateTime
* static LocalDateTime now()从默认时区的系统时间中获取当前日期时间
*/
System.out.println(LocalDateTime.now()); // 2020-08-22T16:59:18.369379
LocalDateTime
LocalDateTime ldt = LocalDateTime.of(2020, 8, 22, 11, 11, 11);
System.out.println(ldt); //2020-08-22T11:11:11
/*
2020
8
22
11
11
11
*/
System.out.println(ldt.getYear());
System.out.println(ldt.getMonthValue());
System.out.println(ldt.getDayOfMonth());
System.out.println(ldt.getHour());
System.out.println(ldt.getMinute());
System.out.println(ldt.getSecond());
// withXXX 与String相似 本身内容不会改变 System.out.println(ldt.withYear(1000).withMonth(1).withDayOfMonth(1).withHour(1).withMinute(1).withSecond(1));//1000-01-01T01:01:01
System.out.println(ldt);//2020-08-22T11:11:11
// plusXXX
System.out.println(ldt.plusYears(1).plusMonths(1).plusDays(1).plusHours(1).plusMinutes(1).plusSeconds(1));//2021-09-23T12:12:12
System.out.println(ldt);//2020-08-22T11:11:11
// minusXXX
System.out.println(ldt.minusYears(1).minusMonths(1).minusDays(1).minusHours(1).minusMinutes(1).minusSeconds(1));//2019-07-21T10:10:10
System.out.println(ldt);//2020-08-22T11:11:11
Instant
java.time.Instant类主要用于描述瞬间的时间点信息
/**
* Instant
* 标准时区
* 不是系统时区
*/
Instant now = Instant.now();
System.out.println(now); //2020-08-22T09:20:48.423697Z
// 将此瞬间与偏移量组合以创建偏移日期时间
OffsetDateTime onow = now.atOffset(ZoneOffset.ofHours(8));
System.out.println(onow); // 2020-08-22T17:24:41.581021+08:00
//long toEpochMilli() 获取距离1970年1月1日0时0分0秒的毫秒数
long offset = now.toEpochMilli();
//static Instant ofEpochMilli(long epochMilli) 根据参数指定的毫秒数来构造对象,参数为距离1970年1月1 日0时0分0秒的毫秒数
Instant now1 = Instant.ofEpochMilli(offset);
System.out.println(now1);
DateTimeFormatter
java.time.format.DateTimeFormatter类主要用于格式化和解析日期
/**
* java.time.format.DateTimeFormatter
*/
// static DateTimeFormatter ofPattern(String pattern)
DateTimeFormatter stf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// String format(TemporalAccessor temporal) 将参数指定日期时间转换为字符串
LocalDateTime now2 = LocalDateTime.now();
System.out.println(stf.format(now2)); // 2020-08-22 17:34:25
// TemporalAccessor parse(CharSequence text) 将参数指定字符串转换为日期时间
TemporalAccessor now3 = stf.parse("2020-08-22 11:11:11");
集合
Java中集合框架顶层框架是:java.util.Collection集合 和 java.util.Map集合。
其中Collection集合中存取元素的基本单位是:单个元素。
其中Map集合中存取元素的基本单位是:单对元素。
Collection接口
java.util.Collection接口是List接口、Queue 接口以及Set接口的父接口,因此该接口里定义的方法
既可用于操作List集合,也可用于操作Queue集合和Set集合。
// 返回包含对象的个数
public int size()
// 判断是否为空
public boolean isEmpty()
// 判断是否包含指定对象
public boolean contains(Object o)
// 获取当前集合的迭代器
public Iterator iterator()
// 向集合中添加对象
public boolean add(Object o)
// 从集合中删除对象
public boolean remove(Object o)
// 判断是否包含参数指定的所有对象
public boolean containsAll(Collection c)
// 用于将参数指定集合c中的所有元素添加到当前集合中
public boolean addAll(Collection c)
// 从集合中删除参数指定的所有对象
// 本质上一个个删除,有元素则删除,否则不删除
public boolean removeAll(Collection c)
// 保留当前集合中存在且参数集合中存在的所有对象 交集
// false - 当前集合没有发生改变
// true - 当前集合发生改变
public boolean retainAll(Collection c)
// 清空集合
public void clear()
Iterator接口
java.util.Iterator接口主要用于描述迭代器对象,可以遍历Collection集合中的所有元素。
java.util.Collection接口继承Iterator接口,因此所有实现Collection接口的实现类都可以使用该迭代器对象。
// 判断集合中是否有可以迭代/访问的元素
public boolean hasNext()
// 用于取出一个元素并指向下一个元素
public Object next()
// default 用于删除访问到的最后一个元素
public void remove()
for each
for(元素类型 变量名 : 数组/集合名称) {
循环体;
}
List接口
java.util.List集合是Collection集合的子集合,该集合中允许有重复的元素并且有先后放入次序。
该集合的主要实现类有:ArrayList类、LinkedList类、Stack类、Vector类。
其中ArrayList类的底层是采用动态数组进行数据管理的,支持下标访问,增删元素不方便。
其中LinkedList类的底层是采用双向链表进行数据管理的,访问不方便,增删元素方便。
可以认为ArrayList和LinkedList的方法在逻辑上完全一样,只是在性能上有一定的差别,ArrayList更适合于随机访问而LinkedList更适合于插入和删除;在性能要求不是特别苛刻的情形下可以忽略这个差别。
其中Stack类的底层是采用动态数组进行数据管理的,该类主要用于描述一种具有后进先出特征的数据结构,叫做栈(last in fifirst out LIFO)。
其中Vector类的底层是采用动态数组进行数据管理的,该类与ArrayList类相比属于线程安全的类,效率比较低,以后开发中基本不用。
Queue集合
java.util.Queue集合是Collection集合的子集合,与List集合属于平级关系。
该集合的主要用于描述具有先进先出特征的数据结构,叫做队列(fifirst in fifirst out FIFO)。
该集合的主要实现类是LinkedList类,因为该类在增删方面比较有优势。
泛型
List<String> lt1 = new LinkedList<String>();
List<Integer> lt2 = new LinkedList<Integer>();
// java7新特性 菱形特性 后面<>里面的数据类型可以省略
List<Double> lt3 = new LinkedList<>();
// lt1 lt2 lt3 不可以相互赋值
// 泛型只在编译时期有效,在运行时期不区分是什么类型。
// 自定义泛型类
public class Person<T> {
private T gender;
}
// 实例化泛型类时应该指定具体的数据类型,并且是引用数据类型而不是基本数据类型。
Person p1 = new Person("1", 18, "g");
Person<Boolean> p2 = new Person<>("2", 18, true);
Person<String> p3 = new Person<>("2", 18, "1");
// 子类继承处理
public class SubPerson extends Person {} // 不保留泛型且不指定类型 T默认Object类型
public class SubPerson extends Person<String> {} // 不保留泛型但指定类型
public class SubPerson<T> extends Person<T> {} // 保留泛型
public class SubPerson<T, E> extends Person<T> {} // 以增加自己的泛型
// 泛型方法
public static <E> void printArr(E[] arr) {
for (E e : arr) {}
}
// 通配符
List<?> lt1 = new LinkedList<>();// 任意类型 不支持元素的添加 取当Object处理
List<? extends Person> lt2 = new LinkedList<>();// Person及子类 不支持元素的添加
List<? super Person> lt3 = new LinkedList<>();// Person及父类 取当Object处理
Set接口
元素没有先后放入次序,且不允许重复
HashSet类的底层是采用哈希表进行数据管理的
TreeSet类的底层是采用红黑树进行数据管理的。
LinkedHashSet类与HashSet类的不同之处在于内部维护了一个双向链表,链表中记录了元素的迭代顺序,也就是元素插入集合中的先后顺序,因此便于迭代
Map接口
java.util.Map<K,V>集合中存取元素的基本单位是:单对元素,其中类型参数如下:
K -此映射所维护的键(Key)的类型,相当于目录。
V - 映射值(Value)的类型,相当于内容。
该集合中 key 是不允许重复的,而且一个 key 只能对应一个 value 。
该集合的主要实现类有: HashMap 类、 TreeMap 类、 LinkedHashMap 类、 Hashtable 类、 Properties 类。
其中 HashMap 类的底层是采用哈希表进行数据管理的。
其中 TreeMap 类的底层是采用红黑树进行数据管理的。
其中 LinkedHashMap 类与 HashMap 类的不同之处在于内部维护了一个双向链表,链表中记录了元素的迭代顺序,也就是元素插入集合中的先后顺序,因此便于迭代。
其中 Hashtable 类是古老的 Map 实现类,与 HashMap 类相比属于线程安全的类,且不允许 null 作为 key 或者 value 的数值。
其中 Properties 类是 Hashtable 类的子类,该对象用于处理属性文件, key 和 value 都是 String 类型的。
Map 集合是面向查询优化的数据结构 , 在大数据量情况下有着优良的查询性能。
经常用于根据 key 检索 value 的业务场景。
Map<String, String> m1 = new HashMap<>();
String str1 = m1.put("1", "one");
System.out.println(str1); // null
System.out.println(m1); // {1=one}
str1 = m1.put("1", "one2");
System.out.println(str1); // one
System.out.println(m1); //{1=one2}
/**
常量:
DEFAULT_INITIAL_CAPACITY : HashMap的默认容量是16。
DEFAULT_LOAD_FACTOR:HashMap的默认加载因子是0.75。
threshold:扩容的临界值,该数值为:容量*填充因子,也就是12。
TREEIFY_THRESHOLD:若Bucket中链表长度大于该默认值则转化为红黑树存储,该数值是8。
MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量,该数值是64。
*/