Java SE 基础篇总结 (下)
6_多线程
6.1 程序、进程、线程的理解
程序(programm)
概念:是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。进程(process)
概念:程序的一次执行过程,或是正在运行的一个程序。
说明:进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域线程(thread)
概念:进程可进一步细化为线程,是一个程序内部的一条执行路径。
说明:线程作为调度和执行的单位,每个线程拥独立的运行栈和程序计数器(pc),线程切换的开销小。
进程可以细化为多个线程。
每个线程,拥有自己独立的:栈、程序计数器
多个线程,共享同一个进程中的结构:方法区、堆。
6.2 并发、并行
- 单核CPU与多核CPU的理解
单核CPU,其实是一种假的多线程,因为在一个时间单元内,也只能执行一个线程的任务。例如:虽然有多车道,但是收费站只有一个工作人员在收费,只有收了费才能通过,那么CPU就好比收费人员。如果某个人不想交钱,那么收费人员可以把他“挂起”(晾着他,等他想通了,准备好了钱,再去收费。)但是因为CPU时间单元特别短,因此感觉不出来。
如果是多核的话,才能更好的发挥多线程的效率。(现在的服务器都是多核的)
一个Java应用程序java.exe,其实至少三个线程:main()主线程,gc()垃圾回收线程,异常处理线程。当然如果发生异常,会影响主线程。 - 并行与并发的理解
并行:多个CPU同时执行多个任务。比如:多个人同时做不同的事。
并发:一个CPU(采用时间片)同时执行多个任务。比如:秒杀、多个人做同一件事
6.3 多线程的方法
6.3.1 自定义线程类继承自Thread类,重写run方法。
public class MyThread extends Thread{public void run(){// 新线程运行的代码}}
MyThread mt = new MyThread();
mt.start();// 自定义线程类创建对象,并调用start方法开启新线程。
6.3.2 自定义线程类实现Runnable接口,实现run方法。
public class MyThread implements Runnable{public void run(){// 新线程运行的代码}
}MyThread mt = new MyThread();// 创建自定义线程类对象
Thread thread = new Thread(mt);// 创建Thread类对象,将自定义线程类对象作为参数传入。
thread.start();// Thread类对象开启start方法。
6.3.3 Thread的常用方法
* 1. start():启动当前线程;调用当前线程的run()
* 2. run(): 通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
* 3. currentThread():静态方法,返回执行当前代码的线程
* 4. getName():获取当前线程的名字
* 5. setName():设置当前线程的名字
* 6. yield():释放当前cpu的执行权
* 7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b完全执行完以后,线程a才结束阻塞状态。
* 8. stop():已过时。当执行此方法时,强制结束当前线程。
* 9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内,当前线程是阻塞状态。
* 10. isAlive():判断当前线程是否存活
6.4 Thread的生命周期
说明:
1.生命周期关注两个概念:状态、相应的方法
2.关注:状态a–>状态b:哪些方法执行了(回调方法)
某个方法主动调用:状态a–>状态b
3. 阻塞:临时状态,不可以作为最终状态
死亡:最终状态。
6.5 线程同步机制
6.5.1.背景
例子:创建个窗口卖票,总票数为100张.使用实现Runnable接口的方式
*
* 1.问题:卖票过程中,出现了重票、错票 -->出现了线程的安全问题
* 2.问题出现的原因:当某个线程操作车票的过程中,尚未操作完成时,其他线程参与进来,也操作车票。
* 3.如何解决:当一个线程a在操作ticket的时候,其他线程不能参与进来。直到线程a操作完ticket时,其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞,也不能被改变。
6.5.2.Java解决方案:同步机制
线程安全产生的问题是:多个线程共享同一个资源时,容易出现线程并发问题。
解决方案:使用同步代码块或者同步方法
同步代码块:
synchronized(同步锁){// 会出现线程并发问题的代码
}
// 使用同步代码块将可能会出现线程并发问题的代码括中,使用线程锁来限制其他线程对这段代码的访问。
// 多个线程共享同一个资源,为了避免并发问题,当一个线程在执行同步代码块中代码时,其他线程不能执行这段代码。
// 必须保证多个线程拿到的是同一个锁对象,当一个线程拿到锁执行同步代码块时,其他线程由于拿不到锁,所以不能执行代码块。当拿到锁的线程执行完所有代码块中的代码,则释放锁对象,其他线程可以争取锁对象,拿到锁对象的线程开始执行同步代码块中的代码。
同步方法:
// 当一个方法体中所有的代码都应该在一个同步代码块中时,则将synchronized关键字提到方法签名上声明,这个时候该方法就变成了同步方法。
public synchronized void methodOne(){// 普通同步方法,该方法的锁对象是this}public static synchronized void methodTwo(){// 静态同步方法,该方法的锁对象是方法所在类的类类对象}
6.5.3.利弊
同步的方式,解决了线程的安全问题。---好处
操作同步代码时,只能一个线程参与,其他线程等待。相当于是一个单线程的过程,效率低。
6.6 线程通讯
生产者和消费者问题:产品的库存数量有上限有下限,为了数量在上限到下限之间。则需要生产线程和消费线程通讯,保证生产和消费的产品数量可以保持在合理的区间。
1.线程通信涉及到的三个方法:
- wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器。
- notify():一旦执行此方法,就会唤醒被wait的一个线程。如果有多个线程被wait,就唤醒优先级高的那个。
- notifyAll():一旦执行此方法,就会唤醒所有被wait的线程。
2.说明:
- 1.wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。
- 2.wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
- 否则,会出现IllegalMonitorStateException异常
- 3.wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类中。
3.面试题:
面试题:sleep() 和 wait()的异同?
- 1.相同点:
一旦执行方法,都可以使得当前的线程进入阻塞状态。
- 2.不同点:
1)两个方法声明的位置不同:Thread类中声明sleep() , Object类中声明wait()2)调用的要求不同:sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中3)关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,wait()会释放锁。
小结释放锁的操作:
小结不会释放锁的操作:
6.7 JDK1.5新增的线程创建方法
新增方式一:实现Callable接口。 — JDK 5.0新增
//1.创建一个实现Callable的实现类class NumThread implements Callable{//2.实现call方法,将此线程需要执行的操作声明在call()中@Overridepublic Object call() throws Exception {int sum = 0;for (int i = 1; i <= 100; i++) {if(i % 2 == 0){System.out.println(i);sum += i;}}return sum;}}public class ThreadNew {public static void main(String[] args) {//3.创建Callable接口实现类的对象NumThread numThread = new NumThread();//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象FutureTask futureTask = new FutureTask(numThread);//5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()new Thread(futureTask).start();try {//6.获取Callable中call方法的返回值//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。Object sum = futureTask.get();System.out.println("总和为:" + sum);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}}
说明:
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
call()可以返回值的。call()可以抛出异常,被外面的操作捕获,获取异常的信息Callable是支持泛型的
新增方式二:使用线程池
class NumberThread implements Runnable{@Overridepublic void run() {for(int i = 0;i <= 100;i++){if(i % 2 == 0){System.out.println(Thread.currentThread().getName() + ": " + i);}}}
}class NumberThread1 implements Runnable{@Overridepublic void run() {for(int i = 0;i <= 100;i++){if(i % 2 != 0){System.out.println(Thread.currentThread().getName() + ": " + i);}}}
}public class ThreadPool {public static void main(String[] args) {//1. 提供指定线程数量的线程池ExecutorService service = Executors.newFixedThreadPool(10);ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;//设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象service.execute(new NumberThread());//适合适用于Runnableservice.execute(new NumberThread1());//适合适用于Runnable// service.submit(Callable callable);//适合使用于Callable//3.关闭连接池service.shutdown();}}
说明:
* 好处:
* 1.提高响应速度(减少了创建新线程的时间)
* 2.降低资源消耗(重复利用线程池中线程,不需要每次都创建)
* 3.便于线程管理
* corePoolSize:核心池的大小
* maximumPoolSize:最大线程数
* keepAliveTime:线程没任务时最多保持多长时间后会终止
面试题:Java中多线程的创建有几种方式?四种。
7_JavaAPI常用类
7.1 String类
java.lang.String类的使用
7.1.1.概述
String:字符串,使用一对""引起来表示。
1.String声明为final的,不可被继承
2.String实现了Serializable接口:表示字符串是支持序列化的。实现了Comparable接口:表示String可以比较大小
3.String内部定义了final char[] value用于存储字符串数据
4.通过字面量的方式(区别于new给一个字符串赋值,此时的字符串值声明在字符串常量池中)。
5.字符串常量池中是不会存储相同内容(使用String类的equals()比较,返回true)的字符串的。
7.1.2.String的不可变性
2.1 说明
1.当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值。
2.当对现的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
3.当调用String的replace()方法修改指定字符或字符串时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
2.2 代码举例
String s1 = "abc";//字面量的定义方式
String s2 = "abc";
s1 = "hello";System.out.println(s1 == s2);//比较s1和s2的地址值System.out.println(s1);//hello
System.out.println(s2);//abcSystem.out.println("*****************");String s3 = "abc";
s3 += "def";
System.out.println(s3);//abcdef
System.out.println(s2);System.out.println("*****************");String s4 = "abc";
String s5 = s4.replace('a', 'm');
System.out.println(s4);//abc
System.out.println(s5);//mbc
7.1.3.String实例化的不同方式
3.1 方式说明
方式一:通过字面量定义的方式
方式二:通过new + 构造器的方式
3.2 代码举例
//通过字面量定义的方式:此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
String s1 = "javaEE";
String s2 = "javaEE";
//通过new + 构造器的方式:此时的s3和s4保存的地址值,是数据在堆空间中开辟空间以后对应的地址值。
String s3 = new String("javaEE");
String s4 = new String("javaEE");System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false
System.out.println(s1 == s4);//false
System.out.println(s3 == s4);//false
7.1.4 字符串拼接方式赋值的对比
4.1 说明
1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中一个是变量,结果就在堆中。
3.如果拼接的结果调用intern()方法,返回值就在常量池中
4.2 代码举例
String s1 = "javaEE";
String s2 = "hadoop";String s3 = "javaEEhadoop";
String s4 = "javaEE" + "hadoop";
String s5 = s1 + "hadoop";
String s6 = "javaEE" + s2;
String s7 = s1 + s2;System.out.println(s3 == s4);//true
System.out.println(s3 == s5);//false
System.out.println(s3 == s6);//false
System.out.println(s3 == s7);//false
System.out.println(s5 == s6);//false
System.out.println(s5 == s7);//false
System.out.println(s6 == s7);//falseString s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
System.out.println(s3 == s8);//true
****************************
String s1 = "javaEEhadoop";
String s2 = "javaEE";
String s3 = s2 + "hadoop";
System.out.println(s1 == s3);//false
+
final String s4 = "javaEE";//s4:常量
String s5 = s4 + "hadoop";
System.out.println(s1 == s5);//true
7.1.5 常用方法
int length():返回字符串的长度: return value.length
char charAt(int index): 返回某索引处的字符return value[index]
boolean isEmpty():判断是否是空字符串:return value.length == 0
String toLowerCase():使用默认语言环境,将 String 中的所字符转换为小写
String toUpperCase():使用默认语言环境,将 String 中的所字符转换为大写
String trim():返回字符串的副本,忽略前导空白和尾部空白
boolean equals(Object obj):比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString):与equals方法类似,忽略大小写
String concat(String str):将指定字符串连接到此字符串的结尾。 等价于用“+”
int compareTo(String anotherString):比较两个字符串的大小
String substring(int beginIndex):返回一个新的字符串,它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex) :返回一个新字符串,它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始boolean contains(CharSequence s):当且仅当此字符串包含指定的 char 值序列时,返回 true
int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始
int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索注:indexOf和lastIndexOf方法如果未找到都是返回-1替换:
String replace(char oldChar, char newChar):返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement):使用指定的字面值替换序列替换此字符串所匹配字面值目标序列的子字符串。
String replaceAll(String regex, String replacement):使用给定的 replacement 替换此字符串所匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement):使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
匹配:
boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。
切片:
String[] split(String regex):根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit):根据匹配给定的正则表达式来拆分此字符串,最多不超过limit个,如果超过了,剩下的全部都放到最后一个元素中。
7.2 StringBuffer、StringBuilder
7.1.1 String、StringBuffer、StringBuilder三者的对比
String:不可变的字符序列;底层使用char[]存储
StringBuffer:可变的字符序列;线程安全的,效率低;底层使用char[]存储
StringBuilder:可变的字符序列;jdk5.0新增的,线程不安全的,效率高;底层使用char[]存储
7.1.2 StringBuffer与StringBuilder的内存解析
以StringBuffer为例:
String str = new String();//char[] value = new char[0];
String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
System.out.println(sb1.length());//
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];//问题1. System.out.println(sb2.length());//3
//问题2. 扩容问题:如果要添加的数据底层数组盛不下了,那就需要扩容底层的数组。默认情况下,扩容为原来容量的2倍 + 2,同时将原数组中的元素复制到新的数组中。指导意义:开发中建议大家使用:StringBuffer(int capacity) 或 StringBuilder(int capacity)
7.1.3 对比String、StringBuffer、StringBuilder三者的执行效率
从高到低排列:StringBuilder > StringBuffer > String
7.1.4 StringBuffer、StringBuilder中的常用方法
增:append(xxx)
删:delete(int start,int end)
改:setCharAt(int n ,char ch) / replace(int start, int end, String str)
查:charAt(int n )
插:insert(int offset, xxx)
长度:length();
*遍历:for() + charAt() / toString()
7.3 API中处理和日期有关的类
7.3.1 jdk1.8之前处理日期的方式
1.获取系统当前时间:
System类中的currentTimeMillis()
long time = System.currentTimeMillis();
//返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
//称为时间戳
System.out.println(time);
2. java.util.Date类与java.sql.Date类
/*java.util.Date类|---java.sql.Date类1.两个构造器的使用>构造器一:Date():创建一个对应当前时间的Date对象>构造器二:创建指定毫秒数的Date对象2.两个方法的使用>toString():显示当前的年、月、日、时、分、秒>getTime():获取当前Date对象对应的毫秒数。(时间戳)3. java.sql.Date对应着数据库中的日期类型的变量>如何实例化>如何将java.util.Date对象转换为java.sql.Date对象*/@Testpublic void test2(){//构造器一:Date():创建一个对应当前时间的Date对象Date date1 = new Date();System.out.println(date1.toString());//Sat Feb 16 16:35:31 GMT+08:00 2019System.out.println(date1.getTime());//1550306204104//构造器二:创建指定毫秒数的Date对象Date date2 = new Date(155030620410L);System.out.println(date2.toString());//创建java.sql.Date对象java.sql.Date date3 = new java.sql.Date(35235325345L);System.out.println(date3);//1971-02-13//如何将java.util.Date对象转换为java.sql.Date对象//情况一:
// Date date4 = new java.sql.Date(2343243242323L);
// java.sql.Date date5 = (java.sql.Date) date4;//情况二:Date date6 = new Date();java.sql.Date date7 = new java.sql.Date(date6.getTime());}
3. java.text.SimpleDataFormat类
SimpleDateFormat对日期Date类的格式化和解析
1.两个操作:
1.1 格式化:日期 --->字符串
1.2 解析:格式化的逆过程,字符串 ---> 日期2.SimpleDateFormat的实例化:new + 构造器//*************照指定的方式格式化和解析:调用带参的构造器*****************
// SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//格式化String format1 = sdf1.format(date);System.out.println(format1);//2019-02-18 11:48:27//解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),//否则,抛异常Date date2 = sdf1.parse("2020-02-18 11:48:27");System.out.println(date2);
4.Calendar类:日历类、抽象类
//1.实例化//方式一:创建其子类(GregorianCalendar的对象//方式二:调用其静态方法getInstance()Calendar calendar = Calendar.getInstance();
// System.out.println(calendar.getClass());//2.常用方法//get()int days = calendar.get(Calendar.DAY_OF_MONTH);System.out.println(days);System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//set()//calendar可变性calendar.set(Calendar.DAY_OF_MONTH,22);days = calendar.get(Calendar.DAY_OF_MONTH);System.out.println(days);//add()calendar.add(Calendar.DAY_OF_MONTH,-3);days = calendar.get(Calendar.DAY_OF_MONTH);System.out.println(days);//getTime():日历类---> DateDate date = calendar.getTime();System.out.println(date);//setTime():Date ---> 日历类Date date1 = new Date();calendar.setTime(date1);days = calendar.get(Calendar.DAY_OF_MONTH);System.out.println(days);
7.3.2 jdk1.8之前处理日期的方式
1.日期时间API的迭代:
第一代:jdk 1.0 Date类
第二代:jdk 1.1 Calendar类,一定程度上替换Date类
第三代:jdk 1.8 提出了新的一套API
2.前两代存在的问题举例:
可变性:像日期和时间这样的类应该是不可变的。
偏移性:Date中的年份是从1900开始的,而月份都从0开始。
格式化:格式化只对Date用,Calendar则不行。
此外,它们也不是线程安全的;不能处理闰秒等。
3.java 8 中新的日期时间API涉及到的包
LocalDate localDate = LocalDate.now();// 获取当前系统时间,只有日期,没有时分秒的格式。
LocalDate localDate1 = LocalDate.of(2020,10,19);// 按照给定的参数生成一个日期,没有时分秒的格式。LocalTime localTime = LocalTime.now();// 获取当前系统时间,只有时分秒,没有日期的格式。
LocalTime localTime1 = LocalTime.of(8,57,43);// 按照给定的参数生成时间,只有时分秒,没有日期的格式LocalDateTime localDateTime = LocalDateTime.now();// 获取当前系统时间,年月日,时分秒都有的格式。
LocalDateTime localDateTime1 = LocalDateTime.of(2020,10,19,8,59,49);// 按照给定的参数生成时间,年月日,时分秒都有的格式localDate.getYear();
localDateTime.getYear();
localTime.getHour();
localDateTime.getHour();
7.4 比较器
7.4.1.Java比较器的使用背景:
Java中的对象,正常情况下,只能进行比较:== 或 != 。不能使用 > 或 < 的
但是在开发场景中,我们需要对多个对象进行排序,言外之意,就需要比较对象的大小。
如何实现?使用两个接口中的任何一个:Comparable 或 Comparator
7.4.2 自然排序:使用Comparable接口
2.1 说明
1.像String、包装类等实现了Comparable接口,重写了compareTo(obj)方法,给出了比较两个对象大小的方式。
2.像String、包装类重写compareTo()方法以后,进行了从小到大的排列
3. 重写compareTo(obj)的规则:如果当前对象this大于形参对象obj,则返回正整数,如果当前对象this小于形参对象obj,则返回负整数,如果当前对象this等于形参对象obj,则返回零。
4. 对于自定义类来说,如果需要排序,我们可以让自定义类实现Comparable接口,重写compareTo(obj)方法。在compareTo(obj)方法中指明如何排序
2.2 自定义类代码举例:
public class Goods implements Comparable{private String name;private double price;//指明商品比较大小的方式:照价格从低到高排序,再照产品名称从高到低排序@Overridepublic int compareTo(Object o) {// System.out.println("**************");if(o instanceof Goods){Goods goods = (Goods)o;//方式一:if(this.price > goods.price){return 1;}else if(this.price < goods.price){return -1;}else{// return 0;return -this.name.compareTo(goods.name);}//方式二:
// return Double.compare(this.price,goods.price);}
// return 0;throw new RuntimeException("传入的数据类型不一致!");}
// getter、setter、toString()、构造器:省略
}
7.4.3 定制排序:使用Comparator接口
3.1 说明
1.背景:
当元素的类型没实现java.lang.Comparable接口而又不方便修改代码,或者实现了java.lang.Comparable接口的排序规则不适合当前的操作,那么可以考虑使用 Comparator 的对象来排序
2.重写compare(Object o1,Object o2)方法,比较o1和o2的大小:
如果方法返回正整数,则表示o1大于o2;
如果返回0,表示相等;
返回负整数,表示o1小于o2。
3.2 代码举例:
Comparator com = new Comparator() {//指明商品比较大小的方式:照产品名称从低到高排序,再照价格从高到低排序@Overridepublic int compare(Object o1, Object o2) {if(o1 instanceof Goods && o2 instanceof Goods){Goods g1 = (Goods)o1;Goods g2 = (Goods)o2;if(g1.getName().equals(g2.getName())){return -Double.compare(g1.getPrice(),g2.getPrice());}else{return g1.getName().compareTo(g2.getName());}}throw new RuntimeException("输入的数据类型不一致");}
}
使用:
- Arrays.sort(goods,com);
- Collections.sort(coll,com);
- new TreeSet(com);
两种排序方式对比: - Comparable接口的方式一旦一定,保证Comparable接口实现类的对象在任何位置都可以比较大小。
- Comparator接口属于临时性的比较。
7.5 其他类
7.5.1 System类
System类代表系统,系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
由于该类的构造器是private的,所以无法创建该类的对象,也就是无法实例化该类。其内部的成员变量和成员方法都是static的,所以也可以很方便的进行调用。
方法:
native long currentTimeMillis()
void exit(int status)
void gc()
String getProperty(String key)
7.5.2 Math类
说明:
① java.math包的BigInteger可以表示不可变的任意精度的整数。
② 要求数字精度比较高,用到java…mathBigDecimal类
// Math产生随机数的方法
double d = Math.random();// 产生0-1之间的随机浮点数
int i = (int)(Math.random() * 10);// 产生随机整数
int i = (int)(Math.random() * 32);// 产生0-31之间的随机整数
7.5.3 Random类:随机类
Random random = new Random();// 创建随机类对象
random.nextBoolean();// 产生随机boolean值
random.nextDouble();// 产生随机double值
random.nextInt();// 产生随机int值
random.nextInt(index);// 产生0到index-1之间的随机整数。
8_枚举和注解的使用
8.1 枚举
8.1.1 枚举类的说明:
- 1.枚举类的理解:类的对象只有有限个,确定的。我们称此类为枚举类
- 2.当需要定义一组常量时,强烈建议使用枚举类
- 3.如果枚举类中只一个对象,则可以作为单例模式的实现方式。
8.1.2 如何自定义枚举类?步骤:
//自定义枚举类
class Season{//1.声明Season对象的属性:private final修饰private final String seasonName;private final String seasonDesc;//2.私化类的构造器,并给对象属性赋值private Season(String seasonName,String seasonDesc){this.seasonName = seasonName;this.seasonDesc = seasonDesc;}//3.提供当前枚举类的多个对象:public static final的public static final Season SPRING = new Season("春天","春暖花开");public static final Season SUMMER = new Season("夏天","夏日炎炎");public static final Season AUTUMN = new Season("秋天","秋高气爽");public static final Season WINTER = new Season("冬天","冰天雪地");//4.其他诉求1:获取枚举类对象的属性public String getSeasonName() {return seasonName;}public String getSeasonDesc() {return seasonDesc;}//4.其他诉求1:提供toString()@Overridepublic String toString() {return "Season{" +"seasonName='" + seasonName + '\'' +", seasonDesc='" + seasonDesc + '\'' +'}';}
}
8.1.3 jdk 5.0 新增使用enum定义枚举类。步骤:
//使用enum关键字枚举类
enum Season1 {//1.提供当前枚举类的对象,多个对象之间用","隔开,末尾对象";"结束SPRING("春天","春暖花开"),SUMMER("夏天","夏日炎炎"),AUTUMN("秋天","秋高气爽"),WINTER("冬天","冰天雪地");//2.声明Season对象的属性:private final修饰private final String seasonName;private final String seasonDesc;//2.私化类的构造器,并给对象属性赋值private Season1(String seasonName,String seasonDesc){this.seasonName = seasonName;this.seasonDesc = seasonDesc;}//4.其他诉求1:获取枚举类对象的属性public String getSeasonName() {return seasonName;}public String getSeasonDesc() {return seasonDesc;}}
8.1.4 使用enum定义枚举类之后,枚举类常用方法:(继承于java.lang.Enum类)
Season1 summer = Season1.SUMMER;//toString():返回枚举类对象的名称System.out.println(summer.toString());// System.out.println(Season1.class.getSuperclass());System.out.println("****************");//values():返回所的枚举类对象构成的数组Season1[] values = Season1.values();for(int i = 0;i < values.length;i++){System.out.println(values[i]);}System.out.println("****************");Thread.State[] values1 = Thread.State.values();for (int i = 0; i < values1.length; i++) {System.out.println(values1[i]);}//valueOf(String objName):返回枚举类中对象名是objName的对象。Season1 winter = Season1.valueOf("WINTER");//如果没objName的枚举类对象,则抛异常:IllegalArgumentException
// Season1 winter = Season1.valueOf("WINTER1");System.out.println(winter);
8.1.5 使用enum定义枚举类之后,如何让枚举类对象分别实现接口:
interface Info{void show();
}//使用enum关键字枚举类
enum Season1 implements Info{//1.提供当前枚举类的对象,多个对象之间用","隔开,末尾对象";"结束SPRING("春天","春暖花开"){@Overridepublic void show() {System.out.println("春天在哪里?");}},SUMMER("夏天","夏日炎炎"){@Overridepublic void show() {System.out.println("宁夏");}},AUTUMN("秋天","秋高气爽"){@Overridepublic void show() {System.out.println("秋天不回来");}},WINTER("冬天","冰天雪地"){@Overridepublic void show() {System.out.println("大约在冬季");}};
}
8.2 注解
8.2.1 注解的理解
① jdk 5.0 新增的功能
*
② Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation,
- 程序员可以在不改变原逻辑的情况下, 在源文件中嵌入一些补充信息。
③在JavaSE中,注解的使用目的比较简单,例如标记过时的功能,忽略警告等。在JavaEE/Android
- 中注解占据了更重要的角色,例如用来配置应用程序的任何切面,代替JavaEE旧版中所遗留的繁冗
- 代码和XML配置等。
框架 = 注解 + 反射机制 + 设计模式
8.2.2 注解的使用示例
示例一:生成文档相关的注解
示例二:在编译时进行格式检查(JDK内置的个基本注解)
@Override: 限定重写父类方法, 该注解只能用于方法
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的择
@SuppressWarnings: 抑制编译器警告示例:跟踪代码依赖性,实现替代配置文件功能
8.2.3 如何自定义注解:参照@SuppressWarnings定义
- ① 注解声明为:@interface
- ② 内部定义成员,通常使用value表示
- ③ 可以指定成员的默认值,使用default定义
- ④ 如果自定义注解没成员,表明是一个标识作用。
说明:
如果注解有成员,在使用注解时,需要指明成员的值。
自定义注解必须配上注解的信息处理流程(使用反射)才意义。
自定义注解通过都会指明两个元注解:Retention、Target
代码举例:
@Inherited
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
public @interface MyAnnotation {String value() default "hello";
}
8.2.4 元注解 :对现有的注解进行解释说明的注解。
jdk 提供的4种元注解:
Retention:指定所修饰的 Annotation 的生命周期:SOURCE\CLASS(默认行为\RUNTIME只声明为RUNTIME生命周期的注解,才能通过反射获取。
Target:用于指定被修饰的 Annotation 能用于修饰哪些程序元素
*******出现的频率较低*******
Documented:表示所修饰的注解在被javadoc解析时,保留下来。
Inherited:被它修饰的 Annotation 将具继承性。
—>类比:元数据的概念:String name = “Tom”;
8.2.5 如何获取注解信息:通过发射来进行获取、调用。
前提:要求此注解的元注解Retention中声明的生命周期状态为:RUNTIME.
8.2.6 JDK8中注解的新特性:可重复注解、类型注解
6.1 可重复注解:① 在MyAnnotation上声明@Repeatable,成员值为MyAnnotations.class② MyAnnotation的Target和Retention等元注解与MyAnnotations相同。6.2 类型注解:
ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中(如:泛型声明。
ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
9_Java集合
9.1 数组和集合
9.1.1 集合与数组存储数据概述:
集合、数组都是对多个数据进行存储操作的结构,简称Java容器。
说明:此时的存储,主要指的是内存层面的存储,不涉及到持久化的存储
9.1.2 数组存储的特点:
一旦初始化以后,其长度就确定了。
数组一旦定义好,其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
比如:String[] arr;int[] arr1;Object[] arr2;
9.1.3 数组存储的弊端:
> 一旦初始化以后,其长度就不可修改。
> 数组中提供的方法非常限,对于添加、删除、插入数据等操作,非常不便,同时效率不高。
> 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用
> 数组存储数据的特点:有序、可重复。对于无序、不可重复的需求,不能满足。
9.1.4 集合存储的优点:
解决数组存储数据方面的弊端。
9.2 Collection接口
9.1.1 单列集合框架结构
|----Collection接口:单列集合,用来存储一个一个的对象
* |----List接口:存储序的、可重复的数据。 -->“动态”数组
* |----ArrayList、LinkedList、Vector
*
* |----Set接口:存储无序的、不可重复的数据 -->高中讲的“集合”
* |----HashSet、LinkedHashSet、TreeSet
9.1.2 Collection接口常用方法:
add(Object obj),addAll(Collection coll),size(),isEmpty(),clear();
contains(Object obj),containsAll(Collection coll),remove(Object obj),removeAll(Collection coll),retainsAll(Collection coll),equals(Object obj);
hasCode(),toArray(),iterator();
9.1.3 Collection集合与数组间的转换
//集合 --->数组:toArray()
Object[] arr = coll.toArray();
for(int i = 0;i < arr.length;i++){System.out.println(arr[i]);
}//拓展:数组 --->集合:调用Arrays类的静态方法asList(T ... t)
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);List arr1 = Arrays.asList(new int[]{123, 456});
System.out.println(arr1.size());//1List arr2 = Arrays.asList(new Integer[]{123, 456});
System.out.println(arr2.size());//2
向Collection接口的实现类的对象中添加数据obj时,要求obj所在类要重写equals().
9.2 迭代器Iterator和foreach循环
9.2.1 遍历Collection的两种方式:
① 使用迭代器Iterator ② foreach循环(或增强for循环)
9.2.2 java.utils包下定义的迭代器接口:Iterator
Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。
Iterator iterator = coll.iterator();
//hasNext():判断是否还下一个元素
while(iterator.hasNext()){//next():①指针下移 ②将下移以后集合位置上的元素返回System.out.println(iterator.next());
}
9.2.3 remove()的使用:
//测试Iterator中的remove()
//如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法,再调用remove都会报IllegalStateException。
//内部定义了remove(),可以在遍历的时候,删除集合中的元素。此方法不同于集合直接调用remove()@Testpublic void test3(){ Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//删除集合中"Tom"Iterator iterator = coll.iterator();while (iterator.hasNext()){// iterator.remove();Object obj = iterator.next();if("Tom".equals(obj)){iterator.remove();
// iterator.remove();}}//遍历集合iterator = coll.iterator();while (iterator.hasNext()){System.out.println(iterator.next());}}
9.2.4 jdk5.0新特性–增强for循环:(foreach循环)
1.遍历集合举例:
@Test
public void test1(){Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//for(集合元素的类型 局部变量 : 集合对象)for(Object obj : coll){System.out.println(obj);}
}
2.遍历数组举例:
@Test
public void test2(){int[] arr = new int[]{1,2,3,4,5,6};//for(数组元素的类型 局部变量 : 数组对象)for(int i : arr){System.out.println(i);}
}
9.3 List接口
- 存储的数据特点:存储序的、可重复的数据。
- 常用方法:(记住)
增:add(Object obj)
删:remove(int index) / remove(Object obj)
改:set(int index, Object ele)
查:get(int index)
插:add(int index, Object ele)
长度:size()
遍历:① Iterator迭代器方式② 增强for循环③ 普通的循环
9.3.1 常用实现类
|----Collection接口:单列集合,用来存储一个一个的对象
- |----List接口:存储序的、可重复的数据。 -->“动态”数组,替换原的数组
** |----ArrayList:作为List接口的主要实现类;线程不安全的,效率高;底层使用Object[] elementData存储
** |----LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表存储
** |----Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储
9.3.2 源码分析(难点)
9.3.2.1 ArrayList的源码分析:
* 2.1 jdk 7情况下
* ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
* list.add(123);//elementData[0] = new Integer(123);
* ...
* list.add(11);//如果此次的添加导致底层elementData数组容量不够,则扩容。
* 默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。
*
* 结论:建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity)
*
* 2.2 jdk 8中ArrayList的变化:
* ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没创建长度为10的数组
*
* list.add(123);//第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]
* ...
* 后续的添加和扩容操作与jdk 7 无异。
* 2.3 小结:jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象
* 的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。
*
9.3.2.2 LinkedList的源码分析:
* 2.1 jdk 7情况下
* ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
* list.add(123);//elementData[0] = new Integer(123);
* ...
* list.add(11);//如果此次的添加导致底层elementData数组容量不够,则扩容。
* 默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。
*
* 结论:建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity)
*
* 2.2 jdk 8中ArrayList的变化:
* ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没创建长度为10的数组
*
* list.add(123);//第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]
* ...
* 后续的添加和扩容操作与jdk 7 无异。
* 2.3 小结:jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象
* 的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。
*4.2 LinkedList的源码分析:
* LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性,默认值为null
* list.add(123);//将123封装到Node中,创建了Node对象。
*
* 其中,Node定义为:体现了LinkedList的双向链表的说法
* private static class Node<E> {E item;Node<E> next;Node<E> prev;Node(Node<E> prev, E element, Node<E> next) {this.item = element;this.next = next;this.prev = prev;}}
4.3 Vector的源码分析:
jdk7和jdk8中通过Vector()构造器创建对象时,底层都创建了长度为10的数组。
在扩容方面,默认扩容为原来的数组长度的2倍。
9.3.2.2 Vector的源码分析:
jdk7和jdk8中通过Vector()构造器创建对象时,底层都创建了长度为10的数组。
在扩容方面,默认扩容为原来的数组长度的2倍。
9.4 Set接口
9.4.1 存储的数据特点:无序的、不可重复的元素
具体的:
以HashSet为例说明:
无序性:不等于随机性。存储的数据在底层数组中并非照数组索引的顺序添加,而是根据数据的哈希值决定的。
不可重复性:保证添加的元素照equals()判断时,不能返回true.即:相同的元素只能添加一个。
9.4.2 元素添加过程:(以HashSet为例)
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置,判断
数组此位置上是否已经元素:
如果此位置上没其他元素,则元素a添加成功。 —>情况1
如果此位置上其他元素b(或以链表形式存在的多个元素,则比较元素a与元素b的hash值:
如果hash值不相同,则元素a添加成功。—>情况2
如果hash值相同,进而需要调用元素a所在类的equals()方法:
equals()返回true,元素a添加失败
equals()返回false,则元素a添加成功。—>情况2
对于添加成功的情况2和情况3而言:元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中,指向原来的元素。
jdk 8 :原来的元素在数组中,指向元素a
总结:七上八下
HashSet底层:数组+链表的结构。(前提:jdk7)
9.4.3 常用实现类:
|----Collection接口:单列集合,用来存储一个一个的对象
* |----Set接口:存储无序的、不可重复的数据 -->高中讲的“集合”
* |----HashSet:作为Set接口的主要实现类;线程不安全的;可以存储null值
* |----LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历
* 在添加数据的同时,每个数据还维护了两个引用,记录此数据前一个数据和后一个数据。 对于频繁的遍历操作,LinkedHashSet效率高于HashSet.
* |----TreeSet:可以照添加对象的指定属性,进行排序。
9.4.4 存储对象所在类的要求:
HashSet/LinkedHashSet:
要求:向Set(主要指:HashSet、LinkedHashSet)中添加的数据,其所在的类一定要重写hashCode()和equals()
要求:重写的hashCode()和equals()尽可能保持一致性:相等的对象必须具有相等的散列码
- 重写两个方法的小技巧:对象中用作 equals() 方法比较的 Field,都应该用来计算 hashCode 值。
TreeSet:
1.自然排序中,比较两个对象是否相同的标准为:compareTo()返回0.不再是equals().
2.定制排序中,比较两个对象是否相同的标准为:compare()返回0.不再是equals().
9.4.5 TreeSet的使用
6.1 使用说明:
1.向TreeSet中添加的数据,要求是相同类的对象。
2.两种排序方式:自然排序(实现Comparable接口 和 定制排序(Comparator)
6.2 常用的排序方式:
//方式一:自然排序
@Testpublic void test1(){TreeSet set = new TreeSet();//失败:不能添加不同类的对象
// set.add(123);
// set.add(456);
// set.add("AA");
// set.add(new User("Tom",12));//举例一:
// set.add(34);
// set.add(-34);
// set.add(43);
// set.add(11);
// set.add(8);//举例二:set.add(new User("Tom",12));set.add(new User("Jerry",32));set.add(new User("Jim",2));set.add(new User("Mike",65));set.add(new User("Jack",33));set.add(new User("Jack",56));Iterator iterator = set.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}}//方式二:定制排序@Testpublic void test2(){Comparator com = new Comparator() {//照年龄从小到大排列@Overridepublic int compare(Object o1, Object o2) {if(o1 instanceof User && o2 instanceof User){User u1 = (User)o1;User u2 = (User)o2;return Integer.compare(u1.getAge(),u2.getAge());}else{throw new RuntimeException("输入的数据类型不匹配");}}};TreeSet set = new TreeSet(com);set.add(new User("Tom",12));set.add(new User("Jerry",32));set.add(new User("Jim",2));set.add(new User("Mike",65));set.add(new User("Mary",33));set.add(new User("Jack",33));set.add(new User("Jack",56));Iterator iterator = set.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}}
9.4 Map接口
9.4.1 常用实现类结构
|----Map:双列数据,存储key-value对的数据 ---类似于高中的函数:y = f(x)
* |----HashMap:作为Map的主要实现类;线程不安全的,效率高;存储null的key和value
* |----LinkedHashMap:保证在遍历map元素时,可以照添加的顺序实现遍历。
* 原因:在原的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素。
* 对于频繁的遍历操作,此类执行效率高于HashMap。
* |----TreeMap:保证照添加的key-value对进行排序,实现排序遍历。此时考虑key的自然排序或定制排序
* 底层使用红黑树
* |----Hashtable:作为古老的实现类;线程安全的,效率低;不能存储null的key和value
* |----Properties:常用来处理配置文件。key和value都是String类型
*
*
* HashMap的底层:数组+链表 (jdk7及之前)
* 数组+链表+红黑树 (jdk 8)
9.4.2 存储结构的理解
Map中的key:无序的、不可重复的,使用Set存储所的key —> key所在的类要重写equals()和hashCode() (以HashMap为例)
Map中的value:无序的、可重复的,使用Collection存储所的value —>value所在的类要重写equals()
一个键值对:key-value构成了一个Entry对象。
Map中的entry:无序的、不可重复的,使用Set存储所的entry
9.4.3 常用方法
- 添加:put(Object key,Object value)
- 删除:remove(Object key)
- 修改:put(Object key,Object value)
- 查询:get(Object key)
- 长度:size()
- 遍历:keySet() / values() / entrySet()
9.4.4 内存结构说明
9.4.4.1 HashMap在jdk7中实现原理:
HashMap map = new HashMap():
* 在实例化以后,底层创建了长度是16的一维数组Entry[] table。
* ...可能已经执行过多次put...
* map.put(key1,value1):
* 首先,调用key1所在类的hashCode()计算key1哈希值,此哈希值经过某种算法计算以后,得到在Entry数组中的存放位置。
* 如果此位置上的数据为空,此时的key1-value1添加成功。 ----情况1
* 如果此位置上的数据不为空,(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值:
* 如果key1的哈希值与已经存在的数据的哈希值都不相同,此时key1-value1添加成功。----情况2
* 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同,继续比较:调用key1所在类的equals(key2)方法,比较:
* 如果equals()返回false:此时key1-value1添加成功。----情况3
* 如果equals()返回true:使用value1替换value2。
*
* 补充:关于情况2和情况3:此时key1-value1和原来的数据以链表的方式存储。
*
* 在不断的添加过程中,会涉及到扩容问题,当超出临界值(且要存放的位置非空)时,扩容。默认的扩容方式:扩容为原来容量的2倍,并将原的数据复制过来。
9.4.4.2 HashMap在jdk8中相较于jdk7在底层实现方面的不同:
- new HashMap():底层没创建一个长度为16的数组
- jdk 8底层的数组是:Node[],而非Entry[]
- 首次调用put()方法时,底层创建长度为16的数组
- jdk7底层结构只:数组+链表。jdk8中底层结构:数组+链表+红黑树。
4.1 形成链表时,七上八下(jdk7:新的元素指向旧的元素。jdk8:旧的元素指向新的元素)
4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时,此时此索引位置上的所数据改为使用红黑树存储。
9.4.4.3 HashMap底层典型属性的属性的说明:
DEFAULT_INITIAL_CAPACITY : HashMap的默认容量,16
DEFAULT_LOAD_FACTOR:HashMap的默认加载因子:0.75
threshold:扩容的临界值,=容量*填充因子:16 * 0.75 => 12
TREEIFY_THRESHOLD:Bucket中链表长度大于该默认值,转化为红黑树:8
MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量:64
9.4.4.4 LinkedHashMap的底层实现原理(了解)
LinkedHashMap底层使用的结构与HashMap相同,因为LinkedHashMap继承于HashMap.
区别就在于:LinkedHashMap内部提供了Entry,替换HashMap中的Node.
9.4.4.5. TreeMap的使用
向TreeMap中添加key-value,要求key必须是由同一个类创建的对象
因为要照key进行排序:自然排序 、定制排序
9.4.6.使用Properties读取配置文件
//Properties:常用来处理配置文件。key和value都是String类型
public static void main(String[] args) {FileInputStream fis = null;try {Properties pros = new Properties();fis = new FileInputStream("jdbc.properties");pros.load(fis);//加载流对应的文件String name = pros.getProperty("name");String password = pros.getProperty("password");System.out.println("name = " + name + ", password = " + password);} catch (IOException e) {e.printStackTrace();} finally {if(fis != null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}
9.5 Collections工具类的使用
9.5.1.作用:
操作Collection和Map的工具类
9.5.2.常用方法:
reverse(List):反转 List 中元素的顺序
shuffle(List):对 List 集合元素进行随机排序
sort(List):根据元素的自然顺序对指定 List 集合元素升序排序
sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List,int, int):将指定 list 集合中的 i 处元素和 j 处元素进行交换
Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
Object max(Collection,Comparator):根据 Comparator 指定的顺序,返回给定集合中的最大元素
Object min(Collection)
Object min(Collection,Comparator)
int frequency(Collection,Object):返回指定集合中指定元素的出现次数
void copy(List dest,List src):将src中的内容复制到dest中
boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换 List 对象的所旧值
说明:ArrayList和HashMap都是线程不安全的,如果程序要求线程安全,我们可以将ArrayList、HashMap转换为线程的。
使用synchronizedList(List list) 和 synchronizedMap(Map map)
9.5.3 数据间的逻辑结构
集合结构
一对一:线性结构
一对多:树形结构
多对多:图形结构
10_泛型
10.1 泛型的理解
1.泛型的概念
所谓泛型,就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返
回值及参数类型。这个类型参数将在使用时(例如,继承或实现这个接口,用这个类型声明变量、
创建对象时确定(即传入实际的类型参数,也称为类型实参)。
2.泛型的引入背景
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象,所以在JDK1.5之前只能把元素类型设计为Object,JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定,其他的部分是确定的,例如关于这个元素如何保存,如何管理等是确定的,因此此时把元素的类型设计成一个参数,这个类型参数叫做泛型。Collection,List,ArrayList 这个就是类型参数,即泛型。
10.2 泛型在集合中的使用
- 在集合中使用泛型之前的例子
@Testpublic void test1(){ArrayList list = new ArrayList();//需求:存放学生的成绩list.add(78);list.add(76);list.add(89);list.add(88);//问题一:类型不安全
// list.add("Tom");for(Object score : list){//问题二:强转时,可能出现ClassCastExceptionint stuScore = (Integer) score;System.out.println(stuScore);}}
2. 在集合中使用泛型例子1
@Testpublic void test2(){ArrayList<Integer> list = new ArrayList<Integer>();list.add(78);list.add(87);list.add(99);list.add(65);//编译时,就会进行类型检查,保证数据的安全
// list.add("Tom");//方式一:
// for(Integer score : list){// //避免了强转操作
// int stuScore = score;
//
// System.out.println(stuScore);
//
// }//方式二:Iterator<Integer> iterator = list.iterator();while(iterator.hasNext()){int stuScore = iterator.next();System.out.println(stuScore);}}
3. 在集合中使用泛型例子2
//在集合中使用泛型的情况:以HashMap为例@Testpublic void test3(){// Map<String,Integer> map = new HashMap<String,Integer>();//jdk7新特性:类型推断Map<String,Integer> map = new HashMap<>();map.put("Tom",87);map.put("Jerry",87);map.put("Jack",67);// map.put(123,"ABC");//泛型的嵌套Set<Map.Entry<String,Integer>> entry = map.entrySet();Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();while(iterator.hasNext()){Map.Entry<String, Integer> e = iterator.next();String key = e.getKey();Integer value = e.getValue();System.out.println(key + "----" + value);}}
- 集合中使用泛型总结:
- ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
- ② 在实例化集合类时,可以指明具体的泛型类型
- ③ 指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法、构造器、属性等)使用到类的泛型的位置,都指定为实例化的泛型类型。
- 比如:add(E e) —>实例化以后:add(Integer e)
- ④ 注意点:泛型的类型必须是类,不能是基本数据类型。需要用到基本数据类型的位置,拿包装类替换
- ⑤ 如果实例化时,没指明泛型的类型。默认类型为java.lang.Object类型。
10.3 自定义泛型类、泛型接口、泛型方法
10.3.1.举例:
【Order.java】public class Order<T> {String orderName;int orderId;//类的内部结构就可以使用类的泛型T orderT;public Order(){//编译不通过
// T[] arr = new T[10];//编译通过T[] arr = (T[]) new Object[10];}public Order(String orderName,int orderId,T orderT){this.orderName = orderName;this.orderId = orderId;this.orderT = orderT;}//如下的个方法都不是泛型方法public T getOrderT(){return orderT;}public void setOrderT(T orderT){this.orderT = orderT;}@Overridepublic String toString() {return "Order{" +"orderName='" + orderName + '\'' +", orderId=" + orderId +", orderT=" + orderT +'}';}//静态方法中不能使用类的泛型。
// public static void show(T orderT){// System.out.println(orderT);
// }public void show(){//编译不通过
// try{//
//
// }catch(T t){//
// }}//泛型方法:在方法中出现了泛型的结构,泛型参数与类的泛型参数没任何关系。//换句话说,泛型方法所属的类是不是泛型类都没关系。//泛型方法,可以声明为静态的。原因:泛型参数是在调用方法时确定的。并非在实例化类时确定。public static <E> List<E> copyFromArrayToList(E[] arr){ArrayList<E> list = new ArrayList<>();for(E e : arr){list.add(e);}return list;}
}【SubOrder.java】
public class SubOrder extends Order<Integer> {//SubOrder:不是泛型类public static <E> List<E> copyFromArrayToList(E[] arr){ArrayList<E> list = new ArrayList<>();for(E e : arr){list.add(e);}return list;}}//实例化时,如下的代码是错误的
SubOrder<Integer> o = new SubOrder<>();【SubOrder1.java】
public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类}【测试】
@Testpublic void test1(){//如果定义了泛型类,实例化没指明类的泛型,则认为此泛型类型为Object类型//要求:如果大家定义了类是带泛型的,建议在实例化时要指明类的泛型。Order order = new Order();order.setOrderT(123);order.setOrderT("ABC");//建议:实例化时指明类的泛型Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");order1.setOrderT("AA:hello");}@Testpublic void test2(){SubOrder sub1 = new SubOrder();//由于子类在继承带泛型的父类时,指明了泛型类型。则实例化子类对象时,不再需要指明泛型。sub1.setOrderT(1122);SubOrder1<String> sub2 = new SubOrder1<>();sub2.setOrderT("order2...");}@Testpublic void test3(){ArrayList<String> list1 = null;ArrayList<Integer> list2 = new ArrayList<Integer>();//泛型不同的引用不能相互赋值。
// list1 = list2;Person p1 = null;Person p2 = null;p1 = p2;}//测试泛型方法@Testpublic void test4(){Order<String> order = new Order<>();Integer[] arr = new Integer[]{1,2,3,4};//泛型方法在调用时,指明泛型参数的类型。List<Integer> list = order.copyFromArrayToList(arr);System.out.println(list);}
10.3.2.注意点:
10.3.3.应用场景举例:
【DAO.java】:定义了操作数据库中的表的通用操作。 ORM思想(数据库中的表和Java中的类对应)
public class DAO {//表的共性操作的DAO
//添加一条记录public void add(T t){}//删除一条记录public boolean remove(int index){return false;}//修改一条记录public void update(int index,T t){}//查询一条记录public T getIndex(int index){return null;}//查询多条记录public List<T> getForList(int index){return null;}//泛型方法//举例:获取表中一共有多少条记录?获取最大的员工入职时间?public <E> E getValue(){return null;}}【CustomerDAO.java】:
public class CustomerDAO extends DAO<Customer>{//只能操作某一个表的DAO
}【StudentDAO.java】:
public class StudentDAO extends DAO<Student> {//只能操作某一个表的DAO
}
10.4 通配符
10.4.1.通配符的使用
/*通配符的使用通配符:?类A是类B的父类,G<A>和G<B>是没关系的,二者共同的父类是:G<?>*/@Testpublic void test3(){List<Object> list1 = null;List<String> list2 = null;List<?> list = null;list = list1;list = list2;//编译通过
// print(list1);
// print(list2);//List<String> list3 = new ArrayList<>();list3.add("AA");list3.add("BB");list3.add("CC");list = list3;//添加(写入):对于List<?>就不能向其内部添加数据。//除了添加null之外。
// list.add("DD");
// list.add('?');list.add(null);//获取(读取):允许读取数据,读取的数据类型为Object。Object o = list.get(0);System.out.println(o);}public void print(List<?> list){Iterator<?> iterator = list.iterator();while(iterator.hasNext()){Object obj = iterator.next();System.out.println(obj);}}
10.4.2.涉及通配符的集合的数据的写入和读取:
见上
10.4.3.有限制条件的通配符的使用
/*限制条件的通配符的使用。? extends A:G<? extends A> 可以作为G<A>和G<B>的父类,其中B是A的子类? super A:G<? super A> 可以作为G<A>和G<B>的父类,其中B是A的父类*/@Testpublic void test4(){List<? extends Person> list1 = null;List<? super Person> list2 = null;List<Student> list3 = new ArrayList<Student>();List<Person> list4 = new ArrayList<Person>();List<Object> list5 = new ArrayList<Object>();list1 = list3;list1 = list4;
// list1 = list5;// list2 = list3;list2 = list4;list2 = list5;//读取数据:list1 = list3;Person p = list1.get(0);//编译不通过//Student s = list1.get(0);list2 = list4;Object obj = list2.get(0);编译不通过
// Person obj = list2.get(0);//写入数据://编译不通过
// list1.add(new Student());//编译通过list2.add(new Person());list2.add(new Student());}
11_IO流
11.1、File类:代指硬盘上的文件或者文件夹的类。
- File类的一个对象,代表一个文件或一个文件目录(俗称:文件夹)
- File类声明在java.io包下
- File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法,
- 并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容,必须使用IO流来完成。
- 后续File类的对象常会作为参数传递到流的构造器中,指明读取或写入的"终点".
11.2、File类创建对象:
常用构造器
File(String filePath)
File(String parentPath,String childPath)
File(File parentFile,String childPath)File file = new File("路径");// File类创建对象必须给出一个文件或文件夹的硬盘路径,这个路径可以是绝对路径,也可以是相对路径。
11.3、File类的常用方法
file.length();// 当前文件的所占内存空间,文件的大小,单位是字节file.getName();// 返回当前文件的文件名,不带路径名。file.getParent();// 返回当前文件所在文件夹的路径名,没有文件名file.getAbsolutePath();// 返回当前文件的完整路径名和文件名,返回类型为Stringfile.getAbsoluteFile();// 返回使用当前文件完整路径名和文件名创建的File对象。file.isFile();// 如果当前File对象是文件则返回true,否则返回false。file.isDirectory();// 如果当前File对象是文件夹则返回true,否则返回false。file.exists();// 如果使用file当前路径可以找到硬盘上的文件则返回true,否则返回false。file.delete();// 删除当前File对象代指硬盘文件或文件夹。file.createNewFile();// 创建当前File对象路径代指的硬盘文件。file.mkdir();// 创建当前File对象路径代指的文件夹。
11.4、流的特点:
流有两端,一端一定是程序,另一端可以是硬盘文件(File对象),也可以其他的外界信息。流有流转的内容,字节流和字符流。字节流是基本流,任何一种流其实都是字节流。字符流是在字节流的基础上构建了一些符合传递字符的特点的流。
11.5、流的分类:
5.1:按方向分:输入流和输出流
5.2:按流的内容分:字节流和字符流
5.3:按流的角色分:节点流和处理流
11.6、常用的流对象
1、字节节点流:FileInputStream和FileOutputStream。这两个流可以和File类构建流对象。读取和写出字节内容。
2、字符处理流:BufferedReader和BufferedWriter。这两个流是带缓冲区的字符处理流。需要使用FileReader和FileWriter这两个字符节点流构建对象。
3、转换流:InputStreamReader和OutputStreamWriter。这两个流是字符处理流。作用是将字节节点流转换成字符处理流。
4、对象流:ObjectInputStream和ObjectOutputStream。这两个流是字节处理流。需要字节节点流构建对象。可以将java程序中的对象写入硬盘文件,也可以将硬盘文件中对象读取到java程序中。需要对象流处理的对象必须要求它的类实现Serializable接口。Serializable接口是一个标签接口,接口中没有任何方法和属性。
12_网络编程
12.1 InetAddress类的使用
一、实现网络通信需要解决的两个问题
- 1.如何准确地定位网络上一台或多台主机;定位主机上的特定的应用
- 2.找到主机后如何可靠高效地进行数据传输
二、网络通信的两个要素:
- 1.对应问题一:IP和端口号
- 2.对应问题二:提供网络通信协议:TCP/IP参考模型(应用层、传输层、网络层、物理+数据链路层)
三、通信要素一:IP和端口号
1.IP的理解
- IP:唯一的标识 Internet 上的计算机(通信实体)
- 在Java中使用InetAddress类代表IP
- IP分类:IPv4 和 IPv6 ; 万维网 和 局域网
- 域名: www.baidu.com www.mi.com www.sina.com www.jd.com
- 域名解析:域名容易记忆,当在连接网络时输入一个主机的域名后,域名服务器(DNS)负责将域名转化成IP地址,这样才能和主机建立连接。 -------域名解析
- 本地回路地址:127.0.0.1 对应着:localhost
2.InetAddress类:此类的一个对象就代表着一个具体的IP地址
2.1实例化
getByName(String host) 、 getLocalHost()
2.2常用方法
getHostName() / getHostAddress()
3.端口号:正在计算机上运行的进程。
- 要求:不同的进程不同的端口号
- 范围:被规定为一个 16 位的整数 0~65535。
端口号与IP地址的组合得出一个网络套接字:Socket
四、通信要素二:网络通信协议
- 分型模型
2.TCP和UDP的区别
3.TCP三次握手和四次挥手
12.2 Tcp网络编程
代码示例1:客户端发送信息给服务端,服务端将数据显示在控制台上
//客户端@Testpublic void client() {Socket socket = null;OutputStream os = null;try {//1.创建Socket对象,指明服务器端的ip和端口号InetAddress inet = InetAddress.getByName("192.168.14.100");socket = new Socket(inet,8899);//2.获取一个输出流,用于输出数据os = socket.getOutputStream();//3.写出数据的操作os.write("你好,我是客户端mm".getBytes());} catch (IOException e) {e.printStackTrace();} finally {//4.资源的关闭if(os != null){try {os.close();} catch (IOException e) {e.printStackTrace();}}if(socket != null){try {socket.close();} catch (IOException e) {e.printStackTrace();}}}}//服务端@Testpublic void server() {ServerSocket ss = null;Socket socket = null;InputStream is = null;ByteArrayOutputStream baos = null;try {//1.创建服务器端的ServerSocket,指明自己的端口号ss = new ServerSocket(8899);//2.调用accept()表示接收来自于客户端的socketsocket = ss.accept();//3.获取输入流is = socket.getInputStream();//不建议这样写,可能会乱码
// byte[] buffer = new byte[1024];
// int len;
// while((len = is.read(buffer)) != -1){// String str = new String(buffer,0,len);
// System.out.print(str);
// }//4.读取输入流中的数据baos = new ByteArrayOutputStream();byte[] buffer = new byte[5];int len;while((len = is.read(buffer)) != -1){baos.write(buffer,0,len);}System.out.println(baos.toString());System.out.println("收到了来自于:" + socket.getInetAddress().getHostAddress() + "的数据");} catch (IOException e) {e.printStackTrace();} finally {if(baos != null){//5.关闭资源try {baos.close();} catch (IOException e) {e.printStackTrace();}}if(is != null){try {is.close();} catch (IOException e) {e.printStackTrace();}}if(socket != null){try {socket.close();} catch (IOException e) {e.printStackTrace();}}if(ss != null){try {ss.close();} catch (IOException e) {e.printStackTrace();}}}}
代码示例2:客户端发送文件给服务端,服务端将文件保存在本地。
/*
这里涉及到的异常,应该使用try-catch-finally处理*/
@Test
public void client() throws IOException {//1.Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);//2.OutputStream os = socket.getOutputStream();//3.FileInputStream fis = new FileInputStream(new File("beauty.jpg"));//4.byte[] buffer = new byte[1024];int len;while((len = fis.read(buffer)) != -1){os.write(buffer,0,len);}//5.fis.close();os.close();socket.close();
}/*
这里涉及到的异常,应该使用try-catch-finally处理*/
@Test
public void server() throws IOException {//1.ServerSocket ss = new ServerSocket(9090);//2.Socket socket = ss.accept();//3.InputStream is = socket.getInputStream();//4.FileOutputStream fos = new FileOutputStream(new File("beauty1.jpg"));//5.byte[] buffer = new byte[1024];int len;while((len = is.read(buffer)) != -1){fos.write(buffer,0,len);}//6.fos.close();is.close();socket.close();ss.close();}
代码示例3:从客户端发送文件给服务端,服务端保存到本地。并返回“发送成功”给客户端。并关闭相应的连接。
/*这里涉及到的异常,应该使用try-catch-finally处理*/
@Test
public void client() throws IOException {//1.Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);//2.OutputStream os = socket.getOutputStream();//3.FileInputStream fis = new FileInputStream(new File("beauty.jpg"));//4.byte[] buffer = new byte[1024];int len;while((len = fis.read(buffer)) != -1){os.write(buffer,0,len);}//关闭数据的输出socket.shutdownOutput();//5.接收来自于服务器端的数据,并显示到控制台上InputStream is = socket.getInputStream();ByteArrayOutputStream baos = new ByteArrayOutputStream();byte[] bufferr = new byte[20];int len1;while((len1 = is.read(buffer)) != -1){baos.write(buffer,0,len1);}System.out.println(baos.toString());//6.fis.close();os.close();socket.close();baos.close();
}/*
这里涉及到的异常,应该使用try-catch-finally处理*/
@Test
public void server() throws IOException {//1.ServerSocket ss = new ServerSocket(9090);//2.Socket socket = ss.accept();//3.InputStream is = socket.getInputStream();//4.FileOutputStream fos = new FileOutputStream(new File("beauty2.jpg"));//5.byte[] buffer = new byte[1024];int len;while((len = is.read(buffer)) != -1){fos.write(buffer,0,len);}System.out.println("图片传输完成");//6.服务器端给予客户端反馈OutputStream os = socket.getOutputStream();os.write("你好,美女,照片我已收到,非常漂亮!".getBytes());//7.fos.close();is.close();socket.close();ss.close();os.close();}
12.3 UDP网络编程
代码示例:
//发送端
@Test
public void sender() throws IOException {DatagramSocket socket = new DatagramSocket();String str = "我是UDP方式发送的导弹";byte[] data = str.getBytes();InetAddress inet = InetAddress.getLocalHost();DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);socket.send(packet);socket.close();}
//接收端
@Test
public void receiver() throws IOException {DatagramSocket socket = new DatagramSocket(9090);byte[] buffer = new byte[100];DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);socket.receive(packet);System.out.println(new String(packet.getData(),0,packet.getLength()));socket.close();
}
12.4 URL编程
12.4.1.URL(Uniform Resource Locator)的理解:
统一资源定位符,对应着互联网的某一资源地址
12.4.2.URL的5个基本结构:
- http://localhost:8080/examples/beauty.jpg?username=Tom
- 协议 主机名 端口号 资源地址 参数列表
12.4.3.如何实例化:
URL url = new URL(“http://localhost:8080/examples/beauty.jpg?username=Tom”);
12.4.4.常用方法:
12.4.5.可以读取、下载对应的url资源:
public static void main(String[] args) {HttpURLConnection urlConnection = null;InputStream is = null;FileOutputStream fos = null;try {URL url = new URL("http://localhost:8080/examples/beauty.jpg");urlConnection = (HttpURLConnection) url.openConnection();urlConnection.connect();is = urlConnection.getInputStream();fos = new FileOutputStream("day10\\beauty3.jpg");byte[] buffer = new byte[1024];int len;while((len = is.read(buffer)) != -1){fos.write(buffer,0,len);}System.out.println("下载完成");} catch (IOException e) {e.printStackTrace();} finally {//关闭资源if(is != null){try {is.close();} catch (IOException e) {e.printStackTrace();}}if(fos != null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}if(urlConnection != null){urlConnection.disconnect();}}
}
13_Java反射机制
Reflection(反射)是被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何
类的内部信息,并能直接操作任意对象的内部属性及方法。
框架 = 反射 + 注解 + 设计模式。
13.1 反射的概念
13.1.1 体会反射机制的“动态性”
//体会反射的动态性
@Test
public void test2(){for(int i = 0;i < 100;i++){int num = new Random().nextInt(3);//0,1,2String classPath = "";switch(num){case 0:classPath = "java.util.Date";break;case 1:classPath = "java.lang.Object";break;case 2:classPath = "com.atguigu.java.Person";break;}try {Object obj = getInstance(classPath);System.out.println(obj);} catch (Exception e) {e.printStackTrace();}}}/*
创建一个指定类的对象。
classPath:指定类的全类名*/
public Object getInstance(String classPath) throws Exception {Class clazz = Class.forName(classPath);return clazz.newInstance();
}
13.1.2 反射机制能提供的功能
java.lang.Class:反射的源头
java.lang.reflect.Method
java.lang.reflect.Field
java.lang.reflect.Constructor
13.2 Class类的理解
13.2.1 Class类的理解
1.类的加载过程:
程序经过javac.exe命令以后,会生成一个或多个字节码文件(.class结尾)。
接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件
加载到内存中。此过程就称为类的加载。加载到内存中的类,我们就称为运行时类,此
运行时类,就作为Class的一个实例。
2.换句话说,Class的实例就对应着一个运行时类。
3.加载到内存中的运行时类,会缓存一定的时间。在此时间之内,我们可以通过不同的方式
来获取此运行时类。
13.2.2 获取Class实例的几种方式:
//方式一:调用运行时类的属性:.classClass clazz1 = Person.class;System.out.println(clazz1);//方式二:通过运行时类的对象,调用getClass()Person p1 = new Person();Class clazz2 = p1.getClass();System.out.println(clazz2);//方式三:调用Class的静态方法:forName(String classPath)Class clazz3 = Class.forName("com.sz.java.Person");
// clazz3 = Class.forName("java.lang.String");System.out.println(clazz3);System.out.println(clazz1 == clazz2);System.out.println(clazz1 == clazz3);//方式四:使用类的加载器:ClassLoader (了解)ClassLoader classLoader = ReflectionTest.class.getClassLoader();Class clazz4 = classLoader.loadClass("com.sz.java.Person");System.out.println(clazz4);System.out.println(clazz1 == clazz4);
13.2.3.总结:创建类的对象的方式?
方式一:
new + 构造器
方式二:
要创建Xxx类的对象,可以考虑:Xxx、Xxxs、XxxFactory、XxxBuilder类中查看是否有
静态方法的存在。可以调用其静态方法,创建Xxx对象。
方式三:
通过反射
13.2.4.Class实例可以是哪些结构的说明
13.3 ClassLoader
13.3.1.类的加载过程----了解
13.3.2.类的加载器的作用
13.3.3.类的加载器的分类
13.3.4.Java类编译、运行的执行的流程
13.3.5.使用Classloader加载src目录下的配置文件
@Testpublic void test2() throws Exception {Properties pros = new Properties();//此时的文件默认在当前的module下。//读取配置文件的方式一:
// FileInputStream fis = new FileInputStream("jdbc.properties");
// FileInputStream fis = new FileInputStream("src\\jdbc1.properties");
// pros.load(fis);//读取配置文件的方式二:使用ClassLoader//配置文件默认识别为:当前module的src下ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();InputStream is = classLoader.getResourceAsStream("jdbc1.properties");pros.load(is);String user = pros.getProperty("user");String password = pros.getProperty("password");System.out.println("user = " + user + ",password = " + password);}
14_Java8的新特性
14.1 Java的新特性概述
14.2 Lambda表达式
14.2.1.Lambda表达式使用前后的对比:
举例一:
@Test
public void test1(){Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("我爱北京天安门");}};r1.run();System.out.println("***********************");Runnable r2 = () -> System.out.println("我爱北京故宫");r2.run();
}举例二:
@Test
public void test2(){Comparator<Integer> com1 = new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return Integer.compare(o1,o2);}};int compare1 = com1.compare(12,21);System.out.println(compare1);System.out.println("***********************");//Lambda表达式的写法Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);int compare2 = com2.compare(32,21);System.out.println(compare2);System.out.println("***********************");//方法引用Comparator<Integer> com3 = Integer :: compare;int compare3 = com3.compare(32,21);System.out.println(compare3);
}
14.2.2.Lambda表达式的基本语法:
1.举例: (o1,o2) -> Integer.compare(o1,o2);
2.格式:
-> :lambda操作符 或 箭头操作符
->左边:lambda形参列表 (其实就是接口中的抽象方法的形参列表
->右边:lambda体 (其实就是重写的抽象方法的方法体
14.2.3.如何使用:分为六种情况
总结六种情况:
->左边:lambda形参列表的参数类型可以省略(类型推断);如果lambda形参列表只一个参数,其一对()也可以省略
->右边:lambda体应该使用一对{}包裹;如果lambda体只一条执行语句(可能是return语句,省略这一对{}和return关键字
14.3 函数式接口
14.3.1.函数式接口的使用说明
如果一个接口中,只声明了一个抽象方法,则此接口就称为函数式接口。
我们可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口。
Lambda表达式的本质:作为函数式接口的实例
14.3.2.Java8中关于Lambda表达式提供的4个基本的函数式接口:
具体使用:
14.3.3.总结
3.1 何时使用lambda表达式?
当需要对一个函数式接口实例化的时候,可以使用lambda表达式。
3.2 何时使用给定的函数式接口?
如果我们开发中需要定义一个函数式接口,首先看看在已有的jdk提供的函数式接口是否提供了
能满足需求的函数式接口。如果有,则直接调用即可,不需要自己再自定义了。
14.4 方法引用
14.4.1.理解:
方法引用可以看做是Lambda表达式深层次的表达。换句话说,方法引用就是Lambda表达式,也就是函数式接口的一个实例,通过方法的名字来指向一个方法。
14.4.2.使用情境:
当要传递给Lambda体的操作,已经实现的方法了,可以使用方法引用!
14.4.3.格式:
类(或对象) :: 方法名
14.4.4.分为如下的三种情况:
- 情况1 对象 :: 非静态方法
- 情况2 类 :: 静态方法
- 情况3 类 :: 非静态方法
14.4.5.要求:
要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同!(针对于情况1和情况2)
当函数式接口方法的第一个参数是需要引用方法的调用者,并且第二个参数是需要引用方法的参数(或无参数)时:ClassName::methodName(针对于情况3)
14.4.6.使用建议:
如果给函数式接口提供实例,恰好满足方法引用的使用情境,大家就可以考虑使用方法引用给函数式接口提供实例。如果大家不熟悉方法引用,那么还可以使用lambda表达式。
14.4.7.使用举例:
// 情况一:对象 :: 实例方法
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
@Test
public void test1() {Consumer<String> con1 = str -> System.out.println(str);con1.accept("深圳");System.out.println("*******************");PrintStream ps = System.out;Consumer<String> con2 = ps::println;con2.accept("shenzhen");
}//Supplier中的T get()
//Employee中的String getName()
@Test
public void test2() {Employee emp = new Employee(1001,"Tom",23,5600);Supplier<String> sup1 = () -> emp.getName();System.out.println(sup1.get());System.out.println("*******************");Supplier<String> sup2 = emp::getName;System.out.println(sup2.get());}// 情况二:类 :: 静态方法
//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)
@Test
public void test3() {Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);System.out.println(com1.compare(12,21));System.out.println("*******************");Comparator<Integer> com2 = Integer::compare;System.out.println(com2.compare(12,3));}//Function中的R apply(T t)
//Math中的Long round(Double d)
@Test
public void test4() {Function<Double,Long> func = new Function<Double, Long>() {@Overridepublic Long apply(Double d) {return Math.round(d);}};System.out.println("*******************");Function<Double,Long> func1 = d -> Math.round(d);System.out.println(func1.apply(12.3));System.out.println("*******************");Function<Double,Long> func2 = Math::round;System.out.println(func2.apply(12.6));
}// 情况:类 :: 实例方法 (难度)
// Comparator中的int comapre(T t1,T t2)
// String中的int t1.compareTo(t2)
@Test
public void test5() {Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);System.out.println(com1.compare("abc","abd"));System.out.println("*******************");Comparator<String> com2 = String :: compareTo;System.out.println(com2.compare("abd","abm"));
}//BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
@Test
public void test6() {BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);System.out.println(pre1.test("abc","abc"));System.out.println("*******************");BiPredicate<String,String> pre2 = String :: equals;System.out.println(pre2.test("abc","abd"));
}// Function中的R apply(T t)
// Employee中的String getName();
@Test
public void test7() {Employee employee = new Employee(1001, "Jerry", 23, 6000);Function<Employee,String> func1 = e -> e.getName();System.out.println(func1.apply(employee));System.out.println("*******************");Function<Employee,String> func2 = Employee::getName;System.out.println(func2.apply(employee));}
14.5 构造器引用及数组引用
14.5.1.构造器引用格式:
类名::new
14.5.2.构造器引用使用要求:
和方法引用类似,函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型
14.5.3.构造器引用举例:
//Supplier中的T get()//Employee的空参构造器:Employee()@Testpublic void test1(){Supplier<Employee> sup = new Supplier<Employee>() {@Overridepublic Employee get() {return new Employee();}};System.out.println("*******************");Supplier<Employee> sup1 = () -> new Employee();System.out.println(sup1.get());System.out.println("*******************");Supplier<Employee> sup2 = Employee :: new;System.out.println(sup2.get());}//Function中的R apply(T t)@Testpublic void test2(){Function<Integer,Employee> func1 = id -> new Employee(id);Employee employee = func1.apply(1001);System.out.println(employee);System.out.println("*******************");Function<Integer,Employee> func2 = Employee :: new;Employee employee1 = func2.apply(1002);System.out.println(employee1);}//BiFunction中的R apply(T t,U u)@Testpublic void test3(){BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);System.out.println(func1.apply(1001,"Tom"));System.out.println("*******************");BiFunction<Integer,String,Employee> func2 = Employee :: new;System.out.println(func2.apply(1002,"Tom"));}
14.5.4.数组引用格式:
数组类型[] :: new
14.5.5.数组引用举例:
//Function中的R apply(T t)
@Test
public void test4(){Function<Integer,String[]> func1 = length -> new String[length];String[] arr1 = func1.apply(5);System.out.println(Arrays.toString(arr1));System.out.println("*******************");Function<Integer,String[]> func2 = String[] :: new;String[] arr2 = func2.apply(10);System.out.println(Arrays.toString(arr2));}
14.6 Stream API
14.6.1.Stream API的理解:
1.1 Stream关注的是对数据的运算,与CPU打交道
集合关注的是数据的存储,与内存打交道
1.2 java8提供了一套api,使用这套api可以对内存中的数据进行过滤、排序、映射、归约等操作。类似于sql对数据库中表的相关操作。
14.6.2.注意点:
- ①Stream 自己不会存储元素。
- ②Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream。
- ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
14.6.3.Stream的使用流程:
- ① Stream的实例化
- ② 一系列的中间操作(过滤、映射、…)
- ③ 终止操作
14.6.4.使用流程的注意点:
- 4.1 一个中间操作链,对数据源的数据进行处理
- 4.2 一旦执行终止操作,就执行中间操作链,并产生结果。之后,不会再被使用
14.6.5.步骤一:Stream实例化
//创建 Stream方式一:通过集合@Testpublic void test1(){List<Employee> employees = EmployeeData.getEmployees();// default Stream<E> stream() : 返回一个顺序流Stream<Employee> stream = employees.stream();// default Stream<E> parallelStream() : 返回一个并行流Stream<Employee> parallelStream = employees.parallelStream();}//创建 Stream方式二:通过数组@Testpublic void test2(){int[] arr = new int[]{1,2,3,4,5,6};//调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流IntStream stream = Arrays.stream(arr);Employee e1 = new Employee(1001,"Tom");Employee e2 = new Employee(1002,"Jerry");Employee[] arr1 = new Employee[]{e1,e2};Stream<Employee> stream1 = Arrays.stream(arr1);}//创建 Stream方式三:通过Stream的of()@Testpublic void test3(){Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);}//创建 Stream方式四:创建无限流@Testpublic void test4(){// 迭代
// public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)//遍历前10个偶数Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);// 生成
// public static<T> Stream<T> generate(Supplier<T> s)Stream.generate(Math::random).limit(10).forEach(System.out::println);}
14.6.6.步骤二:中间操作![](/assets/blank.gif)
14.6.7.步骤三:终止操作
Collector需要使用Collectors提供实例。
14.7 Optional类的使用
java.util.Optional类
14.7.1.理解:为了解决java中的空指针问题而生!
Optional 类(java.util.Optional) 是一个容器类,它可以保存类型T的值,代表这个值存在。或者仅仅保存null
,表示这个值不存在。原来用 null 表示一个值不存在,现在 Optional 可以更好的表达这个概念。并且可以避
免空指针异常。
14.7.2.常用方法:
@Testpublic void test1(){//empty():创建的Optional对象内部的value = nullOptional<Object> op1 = Optional.empty();if(!op1.isPresent()){//Optional封装的数据是否包含数据System.out.println("数据为空");}System.out.println(op1);System.out.println(op1.isPresent());//如果Optional封装的数据value为空,则get()报错。否则,value不为空时,返回value.
// System.out.println(op1.get());}@Testpublic void test2(){String str = "hello";
// str = null;//of(T t):封装数据t生成Optional对象。要求t非空,否则报错。Optional<String> op1 = Optional.of(str);//get()通常与of()方法搭配使用。用于获取内部的封装的数据valueString str1 = op1.get();System.out.println(str1);}@Testpublic void test3(){String str = "beijing";str = null;//ofNullable(T t) :封装数据t赋给Optional内部的value。不要求t非空Optional<String> op1 = Optional.ofNullable(str);//orElse(T t1):如果Optional内部的value非空,则返回此value值。如果//value为空,则返回t1.String str2 = op1.orElse("shenzhen");System.out.println(str2);//}
Java SE 基础篇总结 (下)相关推荐
- java实现linkstring,【JAVA SE基础篇】32.String类入门
[JAVA SE基础篇]32.String类入门 1.字符串 1.String类又称作不可变字符序列 2.String位于java.lang包中,java程序默认导入java.lang包下所有的类 3 ...
- java 中间容器 表格_【JAVA SE基础篇】45.迭代器、Collections工具类以及使用容器存储表格...
本文将要为您介绍的是[JAVA SE基础篇]45.迭代器.Collections工具类以及使用容器存储表格,具体完成步骤: 1.迭代器 迭代器为我们提供了统一遍历容器(List/Map/Set)的方式 ...
- java se运算符优先级,【JAVA SE基础篇】10.运算符优先级与类型转换
[JAVA SE基础篇]10.运算符优先级与类型转换 1.运算符的优先级 运算符的优先级在考试中会考,了解即可,多用就会熟能生巧 实际使用过程中建议用小括号来分优先级 关键就是:逻辑非>逻辑与& ...
- java se用哪个eclipse_【JAVA SE基础篇】5.eclipse的使用和运行
1.eclipse的版本介绍 所有版本的eclipse都按照系统分为32位和64位,如果你的JDK是32位,eclispe必须也是32位,eclipse应与JDK相符合 eclipse分SE和EE等版 ...
- 零基础入门 自学 JAVA SE 基础篇(九)instanceof final 开闭原则 多态 抽象(abstract)方法与抽象类 接口(interface)
JAVA SE自学 基础篇 多态 instanceof final 开闭原则 多态 抽象(abstract)方法与抽象类 接口(interface) 目标 父类型与子类型之间的转换及instanceo ...
- JAVA SE 基础篇 L11-L12
文章目录 L11 1 统一与变化的和谐--抽象类 (1) 抽象方法的作用 (2) 抽象方法和抽象类 (3) 抽象类编程思想与实现过程 2 内部类 (1) 内部类 (2) 匿名内部类 (3) 匿名内部类 ...
- Java SE 基础篇大全(Java 入门必看)
第一章 java由来.环境搭建 一.Java历史[了解] 1. 1995.5.23 sun推出的一款面向对象的编程语言. 2. Java的发展方向:JavaSE(Java的语言基础).Java ...
- java中file类乱,【JAVA SE基础篇】47.file类的方法
1.file类的方法 1.getName():获取文件名 2.getPath():获取文件路径,设定是相对路径得到的就是相对路径,绝对路径同里 3.getAbsolutePath():获取文件绝对路径 ...
- java unicode32_【JAVA SE基础篇】32.String类入门
1.字符串 1.String类又称作不可变字符序列 2.String位于java.lang包中,java程序默认导入java.lang包下所有的类 3.java字符串就是Unicode字符序列,例如字 ...
最新文章
- 送你6份最新开源代码!含NLP、ML、计算机视觉方向(附代码论文)
- 算法试题 - 找出最小 k 个数
- 成功解决mxnet-tag\mxnet\src\operator\tensor\./matrix_op-inl.h:189: Using target_shape will be deprecated
- MyBatis动态SQL-foreach-数组/List
- c++ 将deque部分元素赋值给vector_《STL源码剖析》学习笔记——序列式容器vector
- ASP.NET2.0快速入门--高级数据方案(3)
- 华为平板matepad pro鸿蒙,华为MatePad Pro 2平板电脑入网:首款预装鸿蒙OS
- 企业如何选择数据分析架构?——谈谈3种架构的利弊
- 连接数据库进行省市区三级联动
- java oracle中文乱码_解决java oracle中文乱码的方法
- hexo+next 给博客添加网易云音乐外链接
- 使用Bookinfo应用测试Kuma服务网格
- Oracle中并行parallel详解
- 智能的未来关键在于发现新的逻辑体系
- 2020蓝桥杯省赛B组
- WPF MVVM架构 程序退出右下角托盘图标简单解决方案
- ICP许可证过期了还能补办吗
- 计算方法(五)函数插值
- MFC添加加瓦系列一之MFC水平与垂直布局
- 山东电销机器人_山东自主研发电销机器人意向客户微信端推送 欢迎来电「南京和付信息科技供应」...