第一阶段模块三-核心类库

最新推荐文章于 2020-11-25 23:32:42 发布
最新推荐文章于 2020-11-25 23:32:42 发布
阅读量320 收藏
点赞数
分类专栏： 拉勾java就业急训营学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28255057/article/details/108172098
版权

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.Bytebyte
java.lang.Shortshort
java.lang.Integerint
java.lang.Longlong
java.lang.Floatfloat
java.lang.Doubledouble
java.lang.Booleanboolean
java.lang.Characterchar
  1. 基本数据类型转换为对应包装类的方式 调用包装类的构造方法或静态方法即可
  2. 获取包装类对象中基本数据类型变量数值的方式 调用包装类中的xxxValue方法即可
  3. 字符串转换为基本数据类型的方式 调用包装类中的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对比
  1. int 是原始类型的数据 占用的空间更少
  2. Integer 是int的包装类，有一个 int 类型的字段存储数据，并且提供了基本操作
  3. 在 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接口

  1. java.util.Map<K,V>集合中存取元素的基本单位是：单对元素，其中类型参数如下:

    K -此映射所维护的键(Key)的类型，相当于目录。

    V - 映射值(Value)的类型，相当于内容。

  2. 该集合中 key 是不允许重复的，而且一个 key 只能对应一个 value 。

  3. 该集合的主要实现类有： HashMap 类、 TreeMap 类、 LinkedHashMap 类、 Hashtable 类、 Properties 类。

    其中 HashMap 类的底层是采用哈希表进行数据管理的。

    其中 TreeMap 类的底层是采用红黑树进行数据管理的。

    其中 LinkedHashMap 类与 HashMap 类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。

    其中 Hashtable 类是古老的 Map 实现类，与 HashMap 类相比属于线程安全的类，且不允许 null 作为 key 或者 value 的数值。

    其中 Properties 类是 Hashtable 类的子类，该对象用于处理属性文件， key 和 value 都是 String 类型的。

  4. Map 集合是面向查询优化的数据结构 , 在大数据量情况下有着优良的查询性能。

  5. 经常用于根据 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。
*/
shj-general
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
阶段一模块三
Ermiteratt的博客
02-28 74
Java核心类库 目录Java核心类库二级目录三级目录 二级目录 三级目录
JAVASE阶段一_模块3
NPCS_JQ的博客
05-18 269
这里写自定义目录标题模块三 模块三 模块三 这是第三个模块了，之前两篇的编写不尽人意，接下来我会尽力写好，并且附上思维导图。 任务一的思维导图： 第十一章：常用类的概述和使用 11.1 常用的包（熟悉） 11.1.1 包的名称和功能 java.lang包 - 该包是Java语言的核心包，并且该包中的所有内容由Java虚拟机自动导入。 如：System类、String类、… java.util包 - 该包是Java语言的工具包，里面提供了大量工具类以及集合类等。 如：Scanner类、Random类、List
Day_1:Java学习（一）：核心类库（1）
weixin_39413476的博客
11-25 88
一、API使用： 1、英文版本，Java官方提供，可直接下载：https://www.oracle.com/java/technologies/javase-jdk15-doc-downloads.html 2、中文版本，第一节课程软件文件夹中提供。 二、常用包：java.base模块中 1、java.lang包（浪包）：由Java虚拟机自动导入，不用import。常用的：System类、String类。。。。 2、java.util包：Java语言工具包。常用的：Scanner\Random\L
JAVA学习第一阶段模块三
miaoit的博客
10-09 559
模块一 Java常用类库 常用类 java.lang包，java虚拟机自动导入的 如System类、String类等 java.util包，java语言工具包 如Scanner类、Random类、List集合等 java.io包，java语言输入输出包，对文件操作相关的类 如FileInputStream类、FileOutputStream类等 java.net包，java语言中的网络包，提供了大量网络编程相关的类 如ServerSocker类、Socker类等 java.sql包，ja
Java学习（第一阶段模块三）2020/5/9-2020/5/16
Alanhui2015的博客
05-22 476
Java学习（第一阶段模块三）任务一：SpringMVC基础回顾及高级深入1.SpringMVC简介1.1 MVC体系结构1.2 对 Restful 风格请求支持 任务一：SpringMVC基础回顾及高级深入 顺利完成模块二的学习，正式进入模块三。 1.SpringMVC简介 1.1 MVC体系结构 经典三层：表现层、业务层、数据处理层（Dao层） MVC设计模式（代码的组织形式）：model模型（数据模型[pojo、vo、po]+业务模型[业务逻辑]）、view视图（jsp、html）、controll
java8中的LocalDate，LocalTime，LocalDateTime与Date的转换和使用
qq_36305027的博客
06-12 6561
package com.wangwenjun.java8;import java.time.Duration;import java.time.Instant;import java.time.LocalDate;import java.time.LocalDateTime;import java.time.LocalTime;import java.time.Period;import java...
Spring原理-核心模块
冲吧，不要停！
11-07 2633
最近想了解一下Spring的原理，看了一些文章和书还有源码，稍微了解了一点，把这些东西总结一下，方便以后回忆。 一，Spring核心模块介绍 在这之前，需要看一下这篇文章（https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/#icomments）， 这篇文章把Spring核心模块的轮廓描述的非常清晰，文章把
java8之localDateTime, ZoneId, Instant使用
热门推荐
思考、总结、专注
01-30 2万+
import java.time.*; import java.time.format.DateTimeFormatter; import java.time.temporal.ChronoField; import java.time.temporal.TemporalAdjusters; import java.util.Date; public class Main { publi
消息队列：Pulsar：Pulsar架构与原理.docx
09-02
消息队列：Pulsar：Pulsar架构与原理.docx
英文字母abc目标检测数据集-VOC格式
09-02
本文件夹含jpg图片和对应xml标签，可以用于目标检测模型的训练。
技术资料分享cadence技术资料（009）.zip
09-02
技术资料分享cadence技术资料（009）.zip
煤矿输送带异物检测数据集VOC+YOLO格式2220张2类别.7z
09-02
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)：2220 标注数量(xml文件个数)：2220 标注数量(txt文件个数)：2220 标注类别数：2 标注类别名称:["bolt","bulk"] 每个类别标注的框数： bolt 框数 = 848 bulk 框数 = 2155 总框数：3003 使用标注工具：labelImg 标注规则：对类别进行画矩形框 重要说明：暂无 特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注 更多信息：https://blog.csdn.net/FL1768317420/article/details/141827883
小北使用Python和pyecharts对我校通信学院2024大数据专业就业情况进行中国地图可视化
09-02
小北使用Python和pyecharts对我校通信学院2024大数据专业就业情况进行中国地图可视化
naifei包，索尼电视安装
09-02
naifei包，索尼电视安装
实时计算：Azure Stream Analytics：性能优化：数据流处理的最佳实践.docx
09-02
实时计算：Azure Stream Analytics：性能优化：数据流处理的最佳实践.docx
openssh-2.1.1p4.tar.gz~openssh-9.8p1.tar.gz.zip
最新发布
09-02
openssh-2.1.1p4.tar.gz openssh-2.5.1p1.tar.gz openssh-2.9.9p1.tar.gz openssh-3.0.1p1.tar.gz openssh-3.2.2p1.tar.gz openssh-3.5p1.tar.gz openssh-3.7.1p2.tar.gz openssh-3.9p1.tar.gz openssh-4.3p1.tar.gz openssh-4.6p1.tar.gz openssh-5.1p1.tar.gz openssh-5.5p1.tar.gz openssh-5.8p2.tar.gz openssh-6.2p1.tar.g openssh-6.6p1.tar.gz openssh-7.0p1.tar.gz .openssh-7.2p2.tar.gz openssh-7.6p1.tar.gz openssh-8.0p1.tar.gz openssh-8.4p1.tar.gz openssh-8.8p1.tar.gz openssh-9.2p1.tar.gz openssh-9.5p1.tar.gz
大数据管理与监控：Cloudera Manager：ClouderaManager安全与权限管理.docx
09-02
大数据管理与监控：Cloudera Manager：ClouderaManager安全与权限管理.docx
8.Git版本管理工具.pdf
09-02
8.Git版本管理工具.pdf
电力及公用事业：海南省虚拟电厂管理中心成立，国内虚拟电厂市场或迎快速发展期.pdf
09-02
电子元件 电子行业 行业分析 数据分析 数据报告 行业报告
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值