1、计算机基本概念
# （1）中央处理器CPU
# （2）每台计算机都有一个内部时钟，以固定的速度发射电子脉冲，速度的单位是赫兹Hz
# （3）持久化存储：磁盘、光驱、U盘
# （4）bit和byte,存0或1就是bit，是计算机最小的存储单位。计算机最基本的存储单元是byte,每个byte由
# 8个bit构成。我们一般都是用byte字节，而非bit。
# （5）CUP—内存—硬盘
# （6）如果电脑慢，如何让电脑变快？扩大内存、固态硬盘
# （7）操作系统、万维网、三分看七分练
# （8）Realtek HD aduio 2nd output未插入-声音管理器-文件夹-禁用前面板插孔检测2、基本语法
（1）命名规范
# 包名，所有字母都小写
# 类名、接口名，所有首字母大写，驼峰命名
# 变量名、方法名，首字母小写，随后驼峰命名
# 常量名，所有字母都大写，多个单词用下划线
（2）数据类型的转换
# 自动类型、强制类型可能导致精度的丢失
# String可以和8种类型做运行，且运算只能是连接运算+
# 进制的转换
（3）运算符
# 算术、赋值、比较、逻辑、位、三元运算符
（4）流程控制
# if-else、if - else if - else if - else
# Scanner scanner=new Scanner(System.in);
# switch-case
package com.day.controller;
import java.util.Scanner;
public class Hello {
public static void main(String []args){
Scanner userInput=new Scanner(System.in);
System.out.println("请输入数字:");
int age=userInput.nextInt();
switch (age){
case 1:
System.out.println("1");
break;
case 2:
System.out.println("2");
break;
case 3:
System.out.println("3");
break;
default:
System.out.println("other");
break;
}
}
}
# 循环结构for、while、do while
package com.day.controller;
import java.util.Scanner;
public class Hello {
public static void main(String []args){
for(int i=0;i<100;i++){
System.out.println("for循环: "+i);
}
int j=0;
while(j<100){
System.out.println("while循环: "+j);
j=j+1;
}
Scanner scanner=new Scanner(System.in);
System.out.println("请输入一个数:");
int number=scanner.nextInt();
while(true){
if(number>0){
System.out.println(number);
number=number-1;
}else if(number<0){
System.out.println(number);
number=number+1;
}else{
System.out.println("number为"+number);
break;
}
}
}
}
# break与continue,break结束当前循环，continue是结束当次循环
package com.day.controller;
public class Hello {
public static void main(String []args){
for(int i=0;i<100;i++){
if(i>10&&i<90){
continue;
}
System.out.println("for循环: "+i);
}
}
}3、数组
（1）概述
# 数组的长度一旦确定以后，不能修改，数组元素默认值，整形默认为0
# 数组的遍历
package com.day.controller;
public class Hello {
public static void main(String []args){
String[] nameArray =new String[10];
for(int i=0;i<10;i++){
nameArray[i]=i+"";
}
System.out.println(nameArray.length);
for(int j=0;j<10;j++){
System.out.println(nameArray[j]);
}
}
}
（2）栈、堆、方法区
（3）二维和多维数组
package com.day.controller;
public class Hello {
public static void main(String []args){
String[][] personArray=new String[2][3];
personArray[0][0]="诸葛亮";
personArray[0][1]="刘备";
personArray[0][2]="赵云";
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
System.out.println(personArray[i][j]);
}
}
}
}
（4）排序、查找
package com.day.controller;
import java.util.Arrays;
public class Hello {
public static void main(String []args){
int[] numberArray={1,6,89,1,3,4,6};
System.out.println("排序前: "+Arrays.toString(numberArray));
Arrays.sort(numberArray);
System.out.println("排序后: "+Arrays.toString(numberArray));
int index=Arrays.binarySearch(numberArray,89);
System.out.println("查找到的位置: "+index);
}
}
（5）空间
# 一维空间，一条线
# 二维空间，面
# 三维空间，体
# 四维空间，startTime——体——>endTime，感知过去、现在、未来
# 五维空间，startTime——体——>endTime+时间过程能感知各种可能性，预知所有可能
# 六维空间，可以改变空间结构，让9步完成的事情，一步到位4、面向对象
（1）类
# 属性、方法、构造器；代码块、内部类
# 类是对事物的描述，是抽象的概念。对象是事物的每个个体，也称为了实例instance
# 类的结构/成员：属性和方法，设计类就是设计类的成员
# 属性=成员变量；方法=成员方法=函数=method
package com.day.controller;
public class Hello {
public static void main(String []args){
Person person=new Person();
person.name="陈翔";
person.age=26;
person.isMan=true;
person.eat();
person.talk("汉语");
}
}
class Person{
// 属性
String name;
int age;
boolean isMan;
// 方法
public void eat(){
System.out.println("吃饭");
}
public void talk(String lang){
System.out.println("说话"+",使用的是"+lang);
}
}
# 设计类—>创建对象—>通过 对象.属性 或 对象.方法 调用对象的结构
# 一个类创造多个对象，每个对象都有一套独立的属性（静态除外）
package com.day.controller;
public class Hello {
public static void main(String []args){
Person person=new Person();
person.name="陈翔";
person.age=26;
person.isMan=true;
person.eat();
person.talk("汉语");
Person person_three=new Person();
person_three=person;
System.out.println(person_three.name);
person_three.name="蘑菇头";
System.out.println(person.name);
}
}
class Person{
// 属性
String name;
int age;
boolean isMan;
// 方法
public void eat(){
System.out.println("吃饭");
}
public void talk(String lang){
System.out.println("说话"+",使用的是"+lang);
}
}
# 属性（成员变量）VS 局部变量，局部变量要初始化。属性在堆空间，局部变量加载到栈空间。
# 修饰符private public protected 缺省
# 方法的声明与使用
# 权限修饰符—>返回值类型（若有返回值必须在声明时指定返回值类型，方法中要使用return）—>方法名（小驼峰、见名知意）—>形参列表（可以是0/1/多个参数）；不能在一个方法里定义另一个方法。
# 匿名对象
package com.day.controller;
public class Hello {
public static void main(String []args){
new Person().eat();
}
}
class Person{
// 属性
String name;
int age;
boolean isMan;
// 方法
public void eat(){
System.out.println("吃饭");
}
public void talk(String lang){
System.out.println("说话"+",使用的是"+lang);
}
}
# 方法重载：同一个类相同方法名，但参数个数不同，参数类型不同
package com.day.controller;
public class Hello {
public static void main(String []args){
Person person=new Person();
person.name="陈翔";
person.age=26;
person.talk("英语");
person.talk("日语","日本人");
}
}
class Person{
// 属性
String name;
int age;
public void eat(){
System.out.println("吃饭");
}
public void talk(String lang){
System.out.println("说话"+",使用的是"+lang);
}
public void talk(String lang,String to){
System.out.println("对"+to+"说话"+",使用的是"+lang);
}
}
# 方法形参的传递机制：形参、实参
# 递归方法：自己调自己
package com.day.controller;
public class Hello {
public static void main(String []args){
int result=new Hello().getSum(10);
System.out.println(result);
}
public int getSum(int a){
if(a==1){
return 1;
}else{
return a+getSum(a-1);
}
}
}
# 代码块，用来初始化类、对象
package com.day.controller;
public class Hello {
public static void main(String[] args){
Bank bank=new Bank();
}
}
class Bank{
String name;
{
name="银行";
System.out.println("非静态代码块执行");
}
static {
System.out.println("静态代码块执行...");
}
public Bank(){
System.out.println("构造函数调用...");
}
}
# 在实际连接数据库是static代码块还是非常实用的
# 内部类,java允许类A声明在类B中，A就是外部类
# 内部类：成员内部类 VS 局部内部类
package com.day.controller;
public class Hello {
public static void main(String[] args){
}
}
class Person{
// 成员内部类
class Brain{
}
static class Leg{
}
public void say(){
// 局部内部类
class A{
}
}
public Person(){
// 局部内部类
class B{
}
}
}
# 作为外部类的成员：调用外部类的结构、被static修饰、可以被权限修饰
# 另一方面作为一个类：可以定义属性、方法、构造器等；可以被final修饰、abstract修饰
# 内部类的实例化
package com.day.controller;
public class Hello {
public static void main(String[] args){
Person person=new Person();
Person.Brain brain=person.new Brain();
// 如果上面内部类加static会简单很多
Person.Leg leg=new Person.Leg();
}
}
class Person{
// 成员内部类
class Brain{
String name;
public Brain(){
System.out.println("我是大脑");
}
}
static class Leg{
}
}
# 局部内部类的使用
package com.day.controller;
public class Hello {
public static void main(String[] args){
}
}
interface Comparable{
void say();
}
class Person{
// 局部内部类,也可以用匿名类
public Comparable getComparable(){
class BrainComparable implements Comparable{
@Override
public void say() {
System.out.println("我是大脑");
}
}
return new BrainComparable();
}
}
（2）面向对象的三大特征
# 封装、继承、多态
# 封装：很多操作，我们不需要内部原理，所以需要封装
package com.day.controller;
public class Hello {
public static void main(String []args){
Animal animal=new Animal();
animal.name="老虎";
animal.setAge(1);
animal.introduce();
animal.eat();
}
}
class Animal{
String name;
private int age;
public void setAge(int age){
this.age=age;
}
public void eat(){
System.out.println("进食");
}
public void introduce(){
System.out.println("我是"+name+",今年"+age+"岁");
}
}
# 封装的体现需要权限修饰符的配合；private 缺省 protected public
# 构造器：主要是用来初始化成员变量
package com.day.controller;
public class Hello {
public static void main(String []args){
Animal animal=new Animal("阿黄",2);
animal.introduce();
}
}
class Animal{
private String name;
private int age;
public Animal(String name,int age){
this.name=name;
this.age=age;
}
public void introduce(){
System.out.println("我是"+name+",今年"+age+"岁");
}
}
# javeBean:类是公共的，有一个无参的公共的构造器，有属性对应get/set方法
# 继承性
package com.day.controller;
public class Hello {
public static void main(String []args){
Person person=new Person("人类",20);
person.eat();
Student student=new Student("学生",20);
student.eat();
student.study();
}
}
class Person{
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public void eat(){
System.out.println("吃饭");
}
}
class Student extends Person{
private String major;
public Student(String name, int age) {
super(name,age);
}
public void study(){
System.out.println("学习");
}
}
/*
class Student{
private String name;
private int age;
private String major;
public Student(String name,int age,String major){
this.name=name;
this.age=age;
this.major=major;
}
public void eat(){
System.out.println("吃饭");
}
public void study(){
System.out.println("学习");
}
}*/
# 继承减少了代码的冗余，便于功能的扩展，为多态提供了前提
# 一个类只能有一个父类（单继承），一个父类可以有多个子类。子父类是相对的概念，可以多层继承。
# 默认继承Object类
package com.day.controller;
public class Hello {
public static void main(String []args){
Person person=new Person();
// toString默认继承Object
// 通过右键Diagrams-show Diagrams-右击-show parents
System.out.println(person.toString());
}
}
class Person{
}
# 方法的重写，方法名和参数要求都一样
package com.day.controller;
public class Hello {
public static void main(String []args){
Person person=new Person("陈翔");
person.eat();
Student student=new Student("学生");
student.eat();
}
}
class Person{
private String name;
public Person(String name){
this.name=name;
}
public void eat(){
System.out.println(name+"在吃饭");
}
}
class Student extends Person{
public Student(String name) {
super(name);
}
@Override
public void eat(){
System.out.println("学生仅仅在食堂吃饭");
}
}
# 子类继承父类后，就获取了父类中声明的属性或方法
# 多态性，可以理解为一个事物的多种状态。父类的引用指向子类的对象
# 父类 instance=new 子类()，在运行时即可使用子类的方法
# 使用前提，类的继承与方法的重写是必要前提
package com.day.controller;
public class Hello {
public static void main(String []args){
Person person=new Person("陈翔");
person.eat();
Person student=new Student("学生");
student.eat();
Person employee=new Employee("工人");
employee.eat();
}
}
class Person{
private String name;
public Person(String name){
this.name=name;
}
public void eat(){
System.out.println(name+"在吃饭");
}
}
class Student extends Person{
public Student(String name) {
super(name);
}
@Override
public void eat(){
System.out.println("学生仅仅在食堂吃饭");
}
}
class Employee extends Person{
public Employee(String name) {
super(name);
}
@Override
public void eat(){
System.out.println("工人在公司吃饭");
}
}
# 多态方法里调用说明
package com.day.controller;
public class Hello {
public static void main(String []args){
Hello hello=new Hello();
hello.polymorphismMethod(new Student("学生"));
hello.polymorphismMethod(new Employee("工人"));
}
public void polymorphismMethod(Person person){
person.eat();
}
}
class Person{
private String name;
public Person(String name){
this.name=name;
}
public void eat(){
System.out.println(name+"在吃饭");
}
}
class Student extends Person{
public Student(String name) {
super(name);
}
@Override
public void eat(){
System.out.println("学生仅仅在食堂吃饭");
}
}
class Employee extends Person{
public Employee(String name) {
super(name);
}
@Override
public void eat(){
System.out.println("工人在公司吃饭");
}
}
# 对象的多态性，只适用于方法，不适用于属性
# 对于重载是早绑定（静态绑定），多态是晚绑定（动态绑定）
# 向下转型可以使用部分情况下不能使用的方法
# instanceof 可以判断a是否是A类的实例
（3）关键字
# this、super、static、final、abstract、interface、package、import
# this可以修饰属性和方法，调内部方法时可以省略，前期建议加上使用
package com.day.controller;
public class Hello {
public static void main(String []args){
Animal animal=new Animal("阿黄",2);
animal.eat();
}
}
class Animal{
private String name;
private int age;
public Animal(String name,int age){
this.name=name;
this.age=age;
}
public void eat(){
//introduce();// 等价加this.
this.introduce();
}
public void introduce(){
System.out.println("我是"+name+",今年"+age+"岁");
}
}
# this调构造器
package com.day.controller;
public class Hello {
public static void main(String []args){
Animal animal=new Animal("阿黄",2);
animal.eat();
Animal nextAnimal=new Animal();
nextAnimal.eat();
}
}
class Animal{
private String name;
private int age;
public Animal(){
this("默认名",0);
}
public Animal(String name,int age){
this.name=name;
this.age=age;
System.out.println("必须执行的代码...");
}
public void eat(){
//introduce();// 等价加this.
this.introduce();
}
public void introduce(){
System.out.println("我是"+name+",今年"+age+"岁");
}
}
# package 打包、import 引包
# 程序debug调试
# super 理解为父类的...，可以调用属性、方法、构造器
package com.day.controller;
public class Hello {
public static void main(String []args){
Person person=new Person("陈翔");
person.eat();
Student student=new Student("学生");
student.eat();
}
}
class Person{
private String name;
public Person(String name){
this.name=name;
}
public void eat(){
System.out.println(name+"在吃饭");
}
}
class Student extends Person{
public Student(String name) {
super(name);// 调父类的构造器
}
@Override
public void eat(){
System.out.println("学生仅仅在食堂吃饭");
//在eat方法被覆盖的情况下,去掉父类的eat的方法,属性也是一样的
super.eat();
}
}
# static关键字的引入，可以共享的属性。可以修饰属性、方法、代码块、内部类
# 静态变量，多个对象共享同一个静态变量
package com.day.controller;
public class Hello {
public static void main(String[] args){
Chinese chinese=new Chinese();
chinese.name="陈翔";
chinese.age=20;
Chinese chinese1=new Chinese();
chinese1.nation ="中国";
System.out.println(chinese.nation);
}
}
class Chinese{
String name;
int age;
static String nation;
}
# 修饰方法，静态方法
package com.day.controller;
public class Hello {
public static void main(String[] args){
Chinese.show();
}
}
class Chinese{
String name;
int age;
static String nation;
public static void show(){
System.out.println("中国人");
}
}
# 在静态的方法内，不能使用this、super关键字
# 属性要不要静态，就要看这个属性是否是固定的，不因对象的不同而改变
# 操作静态属性的方法，工具类
# static的应用，单例设计模式；设计模式就是套路，就是建筑风格、风水
# 在整个软件系统中，某个类只能有一个实例
package com.day.controller;
//饿汉式单例模式的思路
public class Hello {
public static void main(String[] args){
Bank bank=Bank.getBank();
}
}
/*
*1.私有化类的构造器
*2.创建类的对象,必须是静态的
*3.提供公共的静态方法返回类的对象
*/
class Bank{
private static Bank instance=new Bank();
private Bank(){
}
public static Bank getBank(){
return instance;
}
}
# 懒汉式单例模式
package com.day.controller;
//单例模式的思路
public class Hello {
public static void main(String[] args){
Bank bank=Bank.getBank();
}
}
class Bank{
private static Bank instance=null;
private Bank(){
}
public static Bank getBank(){
if(instance==null){
instance=new Bank();
}
return instance;
}
}
# 饿汉式是线程安全的，懒汉式是线程不安全的（到多线程时，可以改成线程安全的）
# final关键字，可以修饰类、方法、变量
# final修饰的类，不能被继承
# final修饰方法，则方法不能被重写
# final修饰变量，则变量不能再被赋值
# final修饰局部变量，也是不能再被赋值
# final修饰形参，形参也不能被重新赋值
# abstract抽象类，将父类设计的很抽象，父类一旦抽象，则不能使用new 父类()，需父类 x=new 子类（）
# 抽象类中一定有构造器，便于子类实例化时调用
# 抽象方法，只有方法的声明，没有方法体
# 有抽象方法，必须是抽象类；抽象类不一定有抽象方法
package com.day.controller;
public class Hello {
public static void main(String[] args){
Person person=new Student("学生");
person.say();
}
}
abstract class Person{
String name;
public Person(String name){
this.name=name;
}
public void eat(){
System.out.println("吃饭");
}
public abstract void say();
}
class Student extends Person{
public Student(String name) {
super(name);
}
@Override
public void say() {
System.out.println("我是学生");
}
}
# abstract不能用修饰符私有化方法、final修饰
# 匿名子类对象
package com.day.controller;
public class Hello {
public static void main(String[] args){
Person person=new Person("匿名"){
@Override
public void say() {
System.out.println("我是匿名");
}
};
person.say();
}
}
abstract class Person{
String name;
public Person(String name){
this.name=name;
}
public void eat(){
System.out.println("吃饭");
}
public abstract void say();
}
# 模板方法设计模式
package com.day.controller;
public class Hello {
public static void main(String[] args){
Template person=new Template(){
@Override
public void code() {
for(int i=0;i<10000;i++){
System.out.println(i);
}
}
};
person.costTime();
}
}
abstract class Template{
public void costTime(){
long startTime=System.currentTimeMillis();
code();
long endTime=System.currentTimeMillis();
System.out.println("花费的时间为: "+(endTime-startTime)+"ms");
}
public abstract void code();
}
# 接口 interface,解决单继承的问题
# 接口和类是并列的结构
package com.day.controller;
public class Hello {
public static void main(String[] args){
Flyable plane=new Plane();
plane.fly();
System.out.println("飞机速度范围"+Flyable.MIN_SPEED+"到"+Flyable.MAX_SPEED);
plane.stop();
}
}
/*
* 1.全局常量、抽象方法、定义静态方法、默认方法
*/
interface Flyable{
// 全局常量,且可省略修饰符
// public static final int MAX_SPEED=7900;// 第一宇宙速度
int MAX_SPEED=7900;
//public static final int MIN_SPEED=1;
int MIN_SPEED=1;
// public abstract void fly();
void fly();
// public abstract void stop();
void stop();
}
class Plane implements Flyable{
@Override
public void fly() {
System.out.println("飞机起飞");
}
@Override
public void stop() {
System.out.println("飞机停飞");
}
}
# java类可以实现多个接口，多实现，弥补了java单继承局限性的问题；继承、实现可以同时写
# 接口和接口之间叫做继承，接口与接口之间可以多继承
# 接口的具体使用，体现了多态性；接口实际上可以看做是一种规范
package com.day.controller;
public class Hello {
public static void main(String[] args){
Computer computer=new Computer();
//USB flash=new Flash();
Flash flash=new Flash();
computer.transferDate(flash);
}
}
interface USB{
void start();
}
class Flash implements USB{
@Override
public void start() {
System.out.println("软盘开始启动...");
}
}
class Printer implements USB{
@Override
public void start() {
System.out.println("打印机开始启动...");
}
}
class Computer{
// 接口的多态性
public void transferDate(USB usb){
usb.start();
System.out.println("开始传输数据...");
}
}
# 接口匿名实现类、匿名对象
package com.day.controller;
public class Hello {
public static void main(String[] args){
Computer computer=new Computer();
computer.transferDate(new USB(){
@Override
public void start() {
System.out.println("匿名USB开始启动...");
}
});
}
}
interface USB{
void start();
}
class Computer{
// 接口的多态性
public void transferDate(USB usb){
usb.start();
System.out.println("开始传输数据...");
}
}
# 接口应用：代理模式-静态代理-动态代理
package com.day.controller;
public class Hello {
public static void main(String[] args){
// 这一步很关键,决定具体的执行
NetWork netWork=new Server();
ProxyServer proxyServer=new ProxyServer(netWork);
proxyServer.browse();
}
}
interface NetWork{
void browse();
}
class Server implements NetWork{
@Override
public void browse() {
System.out.println("真实的服务器访问网络...");
}
}
class ProxyServer implements NetWork{
private NetWork netWork;
public ProxyServer(NetWork netWork){
thisWork=netWork;
}
public void check(){
System.out.println("联网前的检查...");
}
@Override
public void browse() {
check();
netWork.browse();
}
}
# 工厂模式：创建者和调用者分离
# JDK8中接口中还可以定义静态方法和默认方法
package com.day.controller;
public class Hello {
public static void main(String[] args){
// 接口定义的静态方法,只能通过接口调用
NetWork.site();
// 默认方法实现类对象server是可以调用的
NetWork server=new Server();
server.say();
// 而且可以重写,可以用默认的
}
}
interface NetWork{
// 静态方法
static void site(){
System.out.println("北京");
}
// 默认方法
default void say(){
System.out.println("Hello");
}
}
class Server implements NetWork{
public void say(){
System.out.println("Hello我是实现类");
}
}
# 接口冲突
package com.day.controller;
public class Hello {
public static void main(String[] args){
Man man=new Man();
man.help();
}
}
interface Fish{
default void help(){
System.out.println("吃鱼...");
}
}
interface Bear{
default void help(){
System.out.println("吃熊掌...");
}
}
class Father{
public void help(){
System.out.println("鱼与熊掌不可兼得...");
}
}
class Man extends Father implements Fish,Bear{
@Override
public void help() {
System.out.println("吃什么呢?");
Fish.super.help();
Bear.super.help();
}
}
（4）Object和包装类的使用
# Object是所有java类的父类
package com.day.controller;
public class Hello {
public static void main(String []args){
Person person=new Person();
System.out.println(person.getClass().getSuperclass());
}
}
class Person{
}
# Object里的方法调用
package com.day.controller;
public class Hello {
public static void main(String []args){
Person person=new Person("陈翔");
System.out.println(person);
person=null;// 等待被回收,时间不确定
System.gc();// 强制释放空间
}
}
class Person{
String name;
public Person(String name){
this.name=name;
}
// 对象回收之前会调用这个方法
@Override
public void finalize() throws Throwable{
System.out.println("对象被释放---"+this);
}
@Override
public String toString(){
return "Person姓名: "+name;
}
}
# ==和equals方法的使用（只适用于引用数据类型）
# 包装类的使用
# 单元测试方法的使用JUnit
package com.day.controller;
import org.junit.Test;
public class Hello {
@Test
public void testEquals(){
String str="MM";
String str2="MM";
System.out.println(str.equals(str2));
}
}
/*
1.引包
2.此类是public的,提供公共无参构造器
3.方法是public,没有返回值,没有形参
4.方法上需要声明注解:@Test
5.右键run
6.执行正常就是绿条,执行失败是红条
*/
# 包装类Byte Short Integer Long Float Double Boolean Character
# 基本数据类型和包装类的互相转换
package com.day.controller;
public class Hello {
public static void main(String[] args){
int number=10;
Integer myNumber=new Integer(number);
if (myNumber instanceof Integer) {
System.out.println("Integer对象");
}
number=myNumber.intValue();
System.out.println(number+1);
}
}
# 自动装箱以后互相转换更方便，可以直接用5、异常处理
（1）异常类型
# 空指针null
# 读取不存在的文件
# 网络连接终端
# 数组/集合越界
（2）异常处理try...catch...finally
package com.day.controller;
public class Hello {
public static void main(String[] args){
try{
int i=10/0;
System.out.println(i);
}catch (Exception e){
System.out.println("发生异常,请检查");
e.printStackTrace();
}finally {
System.out.println("执行完毕");
}
}
}
（3）异常另一种处理，throws抛出异常
package com.day.controller;
public class Hello{
public static void main(String[] args) throws Exception{
int i=10/0;
System.out.println(i);
}
}
（4）自定义异常
package com.day.controller;
public class Hello{
public static void main(String[] args) throws MyException{
int i=10/0;
System.out.println(i);
}
}
// 自定义异常类
/*
1.继承现有异常类
2.提权全局常量serialVersion
3.提供重载构造器
*/
class MyException extends RuntimeException{
static final long serialVersion=-7034897190745766939L;
public MyException(){
}
public MyException(String message){
super(message);
}
}6、多线程
（1）IDEA概述
# module（模块）可以包含多个project
# Settings- 主题、字体、自动导包、编码、快捷键
# 模板Templates
（2）多线程
# 程序：用程序编写指令组合为了完成某个任务；进程：正在运行中的程序；
# 线程：进程可以细化为线程，若一个进程可以并行执行多个线程，我们就叫做多线程
# 并行：多个CUP同时执行多个任务；
# 并发：一个CUP“同时”执行多个任务；比如秒杀、多人做同一件事；
# 需要多线程：同时执行多个任务、需要等待任务时、需要一台后台运行的程序时。
# 线程创建方法一
package com.day.controller;
public class Hello{
public static void main(String[] args){
MyThread myThread1=new MyThread("1");
MyThread myThread2=new MyThread("2");
myThread1.start();
myThread2.start();
}
}
class MyThread extends Thread{
private String threadName;
public MyThread(String threadName){
this.threadName=threadName;
}
public void run(){
for(int i=0;i<100;i++){
// 用这个方法打印线程名也可以
// System.out.println(Thread.currentThread().getName());
System.out.println("线程: "+threadName+"正在执行...");
}
}
}
# 匿名子类
package com.day.controller;
public class Hello{
public static void main(String[] args){
MyThread myThread1=new MyThread("1");
MyThread myThread2=new MyThread("2");
myThread1.start();
myThread2.start();
// 匿名子类的方式
new Thread("3"){
public void run(){
for(int i=0;i<100;i++){
System.out.println("线程: 3正在执行...");
}
}
}.start();
}
}
class MyThread extends Thread{
private String threadName;
public MyThread(String threadName){
this.threadName=threadName;
}
public void run(){
for(int i=0;i<100;i++){
System.out.println("线程: "+threadName+"正在执行...");
}
}
}
# Thread.currentThread()：静态方法，返回当前代码的线程，getName：获取当前线程的名字，setName；
# yield()：释放当前CUP的执行权
# join():A线程中调B线程.join()，直到B线程执行完毕后才执行A线程；
# sleep():睡眠多少ms
# isAlive()：判断当前线程是否存活
# 线程的优先级：10 1 5 ，优先级高并不能决定先执行；只能说从概率上更大点
# 卖票问题：线程安全问题
package com.day.controller;
public class Hello{
public static void main(String[] args){
Window window1=new Window();
Window window2=new Window();
Window window3=new Window();
window1.setName("窗口1");
window2.setName("窗口2");
window3.setName("窗口3");
window1.start();
window2.start();
window3.start();
}
}
class Window extends Thread{
private static int ticker=100;
public void run(){
while(true){
if(ticker>0){
System.out.println(getName()+"卖票: "+ticker);
ticker=ticker-1;
}else{
break;
}
}
}
}
# 另一种创建线程的方式
package com.day.controller;
public class Hello{
public static void main(String[] args){
MyThread myThread1=new MyThread();
Thread systemThread1=new Thread(myThread1);
// 因为myThread1赋值给了target
systemThread1.start();
Thread systemThread2=new Thread(myThread1);
systemThread2.start();
}
}
class MyThread implements Runnable{
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"打印值: "+i);
}
}
}
# 卖票不加static,因为myThread1只造了一次，用了多次
package com.day.controller;
public class Hello{
public static void main(String[] args){
MyThread myThread1=new MyThread();
Thread systemThread1=new Thread(myThread1);
// 因为myThread1赋值给了target
systemThread1.start();
Thread systemThread2=new Thread(myThread1);
systemThread2.start();
}
}
class MyThread implements Runnable{
private int ticket=100;
@Override
public void run() {
while(true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"卖票,票号为: "+ticket);
ticket=ticket-1;
}else{
break;
}
}
}
}
# 开发中优先使用Runnable接口，没有单继承性的局限性
# 实现方式更适合处理多个线程有共享数据的情况
# 线程的生命周期：新建-就绪-运行-阻塞-死亡
# 卖票过程中出现的重票和错票问题，出现了线程安全的问题...
# 问题出现的原因：A线程未操作完成时，B线程也来操作了
# 如何解决？加锁（上卫生间原理）
# 解决方式：同步代码块、同步方法
# synchronized (同步监视器（锁）){}，任何一个类的对象都可以充当锁
# 要求：多个线程必须共同使用同一把锁！！！这个非常重要，请注意
package com.day.controller;
public class Hello{
public static void main(String[] args){
MyThread myThread1=new MyThread();
Thread systemThread1=new Thread(myThread1);
// 因为myThread1赋值给了target
systemThread1.start();
Thread systemThread2=new Thread(myThread1);
systemThread2.start();
}
}
class MyThread implements Runnable{
private int ticket=100;
private final Object object=new Object();
@Override
public void run() {
while(true){
synchronized (object) {
if (ticket > 0) {
// 负票
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票,票号为: " + ticket);
// 重票
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
ticket = ticket - 1;
} else {
break;
}
}
}
}
}
# 解决了线程安全的问题，“操作同步代码时”只有一个线程参与，其他线程等待，相当于是一个单线程的过程。
package com.day.controller;
public class Hello{
public static void main(String[] args){
Window window1=new Window();
Window window2=new Window();
Window window3=new Window();
window1.setName("窗口1");
window2.setName("窗口2");
window3.setName("窗口3");
window1.start();
window2.start();
window3.start();
}
}
class Window extends Thread{
private static int ticker=100;
private static Object dog=new Object();
public void run(){
while(true){
synchronized (dog) {
if (ticker > 0) {
System.out.println(getName() + "卖票: " + ticker);
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
ticker = ticker - 1;
} else {
break;
}
}
}
}
}
# this.getClass()也可以充当监视器，synchronized (this.getClass())
# 同步方法
package com.day.controller;
public class Hello{
public static void main(String[] args){
MyThread myThread1=new MyThread();
Thread systemThread1=new Thread(myThread1);
// 因为myThread1赋值给了target
systemThread1.start();
Thread systemThread2=new Thread(myThread1);
systemThread2.start();
}
}
class MyThread implements Runnable{
private int ticket=100;
private Boolean flag=false;
@Override
public void run() {
while(true){
Boolean tempFlag=sale();
if(tempFlag){
break;
}
}
}
private synchronized Boolean sale(){
//方法中同步监视器就是this
if (ticket > 0) {
// 负票
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票,票号为: " + ticket);
// 重票
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
ticket = ticket - 1;
}else{
flag=true;
}
return flag;
}
}
# 死锁：两个人吃饭，每一个有一根筷子，都在都对方给另一根筷子，死锁。
# 写程序时需要避免死锁。
package com.day.controller;
public class Hello{
public static void main(String[] args){
StringBuffer stringBuffer1=new StringBuffer();
StringBuffer stringBuffer2=new StringBuffer();
new Thread(() -> {
synchronized (stringBuffer1){
stringBuffer1.append("a");
stringBuffer2.append("1");
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (stringBuffer2){
stringBuffer1.append("b");
stringBuffer2.append("2");
System.out.println(stringBuffer1);
System.out.println(stringBuffer2);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (stringBuffer2){
stringBuffer1.append("c");
stringBuffer2.append("3");
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (stringBuffer1){
stringBuffer1.append("d");
stringBuffer2.append("4");
System.out.println(stringBuffer1);
System.out.println(stringBuffer2);
}
}
}
}).start();
}
}
# Lock锁方式解决线程安全问题，JDK5.0新增的
# idea按ctrl+p可以提示这个对象有哪些参数
package com.day.controller;
import java.util.concurrent.locks.ReentrantLock;
public class Hello{
public static void main(String[] args){
Window window=new Window();
Thread systemThread1=new Thread(window);
Thread systemThread2=new Thread(window);
Thread systemThread3=new Thread(window);
systemThread1.start();
systemThread2.start();
systemThread3.start();
}
}
class Window implements Runnable{
private int ticket=100;
private ReentrantLock reentrantLock=new ReentrantLock();
@Override
public void run() {
while (true) {
// reentrantLock锁定
reentrantLock.lock();
try {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "卖票,票号: " + ticket);
ticket = ticket - 1;
} else {
break;
}
}finally {
reentrantLock.unlock();// 解锁
}
}
}
}
# 线程的通信（线程的交流而已）
# this.getClass().notifyAll(); synchronized (this.getClass())； this.getClass().wait();
# 注意要统一用this.getClass()，不然就会抛出异常！！！
package com.day.controller;
import java.util.concurrent.locks.ReentrantLock;
public class Hello{
public static void main(String[] args){
Window window=new Window();
Thread systemThread1=new Thread(window);
Thread systemThread2=new Thread(window);
systemThread1.start();
systemThread2.start();
}
}
class Window implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
synchronized (this.getClass()) {
this.getClass().notifyAll();
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票,票号: " + ticket);
ticket = ticket - 1;
try {
// 使得调用wait方法的线程进入阻塞
this.getClass().wait();
} catch (Exception e) {
e.printStackTrace();
}
} else {
break;
}
}
}
}
}
# 生产者、消费者问题
package com.day.controller;
public class Hello{
public static void main(String[] args){
Clerk clerk=new Clerk();
Producer producer1=new Producer(clerk);
producer1.setName("生产者1");
Customer customer1=new Customer(clerk);
customer1.setName("消费者1");
producer1.start();
customer1.start();
Customer customer2=new Customer(clerk);
customer2.setName("消费者2");
customer2.start();
}
}
class Clerk{
private int productCount=0;
// 生产
public synchronized void produceProduct() {
if(productCount<20){
productCount=productCount+1;
System.out.println(Thread.currentThread().getName()+"开始生产第"+productCount+"个产品");
this.notifyAll();
}else{
// 等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 消费
public synchronized void consumeProduct() {
if(productCount>0){
System.out.println(Thread.currentThread().getName()+"开始消费第"+productCount+"个产品");
productCount=productCount-1;
this.notifyAll();
}else{
// 等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Producer extends Thread{
private Clerk clerk;
public Producer(Clerk clerk){
this.clerk=clerk;
}
public void run(){
System.out.println(getName()+"开始生产...");
while(true){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
class Customer extends Thread{
private Clerk clerk;
public Customer(Clerk clerk){
this.clerk=clerk;
}
public void run(){
while(true){
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
# Callable接口与线程池
# Callable功能更强大，可以有返回值
package com.day.controller;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
public class Hello{
public static void main(String[] args){
MyThread myThread=new MyThread();
FutureTask futureTask=new FutureTask(myThread);
new Thread(futureTask).start();
try {
// get方法返回值,就是call()方法的返回值
Object sum=futureTask.get();
System.out.println(sum);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class MyThread implements Callable{
@Override
public Object call() throws Exception {
int sum=0;
for(int i=0;i<=100;i++){
System.out.println(i);
sum=sum+i;
}
return sum;
}
}
# 使用线程池的方式，在开发中都是用线程池！！！
package com.day.controller;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
public class Hello{
public static void main(String[] args){
ThreadPoolExecutor threadPoolExecutor= (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
// 属性的设置,线程池中允许的最大线程数
threadPoolExecutor.setMaximumPoolSize(15);
threadPoolExecutor.execute(new MyThread());// Runnable
threadPoolExecutor.execute(new MyThread());
//executorService.submit();// Callable
threadPoolExecutor.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+": "+i);
}
}
}7、常用类
（1）String、StringBuffer、StringBuilder
# String代表不可变的字符序列，简称不可变性
package com.day.controller;
public class Hello{
public static void main(String[] args){
// Serializable表示字符串是支持序列化的
// 对象是可以进行传输的
String str1="abc";
String str2="abc";
// 比较str1与str2的地址值
System.out.println(str1==str2);
str1="Hello";// 对字符串重新复制,就重新指定了内存区域
System.out.println(str1);
System.out.println(str2);
str1=str1.replace("H","h");
System.out.println(str1);
}
}
# 字符串的创建方式
package com.day.controller;
public class Hello{
public static void main(String[] args){
String str1="Hello";
String str2=new String("Hi");
System.out.println(str1);
System.out.println(str2);
}
}
# String的常用方法
package com.day.controller;
public class Hello{
public static void main(String[] args){
String str="Hello";
System.out.println(str.length());
System.out.println(str.charAt(0));
System.out.println(str.isEmpty());
System.out.println(str.toLowerCase());
System.out.println(str.toUpperCase());
// str是不可变的,想变需要重新赋值
String str1=" Hell o ";
// 取出收尾空格
String str2=str1.trim();
System.out.println("-"+str1+"---VS---"+str2+"-");
String str3=str1.substring(0,3);
System.out.println(str3);
}
}
# 常用方法二
package com.day.controller;
public class Hello{
public static void main(String[] args){
String str="Hello";
System.out.println(str.endsWith("lo"));
System.out.println(str.startsWith("H"));
System.out.println(str.contains("e"));
System.out.println(str.indexOf("llo"));
System.out.println(str.indexOf("hi"));
}
}
# 常用方法三
package com.day.controller;
public class Hello{
public static void main(String[] args){
String str="Hello";
System.out.println(str.replace("H","h"));
System.out.println(str.replaceAll("l","A"));
String[] strArray=str.split("");
for(int i=0;i<strArray.length;i++){
System.out.print(strArray[i]+",");
}
}
}
# String和基本数据类型、包装类的转换
package com.day.controller;
public class Hello{
public static void main(String[] args){
String str="123";
int number=Integer.parseInt(str);
System.out.println(number);
System.out.println(String.valueOf(number));
System.out.println(number+"");
}
}
# String与byte[]之间的转换
package com.day.controller;
import java.util.Arrays;
public class Hello{
public static void main(String[] args){
// 字符串—>字节数组
String str="abc123中国";
byte[] byteArray=str.getBytes();
for(int i=0;i<byteArray.length;i++){
System.out.print(byteArray[i]+" ");
}
System.out.println();
System.out.println(Arrays.toString(byteArray));
// 字节数组->字符串
System.out.println(new String(byteArray));
}
}
# StringBuffer与StringBuilder
# StringBuffer是线程安全的，StringBuilder是线程不安全的、效率高；
# 用哪个就看是否是多线程场景
package com.day.controller;
public class Hello{
public static void main(String[] args){
StringBuffer stringBuffer=new StringBuffer("Hi");
stringBuffer.setCharAt(0, 'm');
System.out.println(stringBuffer);
stringBuffer.append("中国");
System.out.println(stringBuffer);
//stringBuffer.delete(0,2);
//stringBuffer.replace(0,2,"Hello");
stringBuffer.insert(2,false);
System.out.println(stringBuffer);
}
}
（2）时间API
# System与Date
package com.day.controller;
import java.util.Date;
public class Hello{
public static void main(String[] args){
// System类
long startTime=System.currentTimeMillis();
// 1970.1.1 0 0 0 到当前的时间戳
System.out.println(startTime);
// Date类
Date date=new Date();
System.out.println(date);
System.out.println(date.getTime());
}
}
# util.Date与sql.Date
package com.day.controller;
import java.util.Date;
public class Hello{
public static void main(String[] args){
/*Date date=new Date(1631447269255L);
System.out.println(date);*/
Date date=new Date(1631447269255L);
// 自带日期转换为SQL日期
java.sql.Date sqlDate=new java.sql.Date(date.getTime());
}
}
# 日期格式化
package com.day.controller;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Hello{
public static void main(String[] args){
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(new Date());
System.out.println(simpleDateFormat.format(new Date()));
}
}
# Calendar日历类
package com.day.controller;
import java.util.Calendar;
import java.util.Date;
public class Hello{
public static void main(String[] args){
// Calendar日历类
Calendar calendar= Calendar.getInstance();
int days=calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);
/*calendar.set(Calendar.DAY_OF_MONTH,22);
days=calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);*/
calendar.add(Calendar.DAY_OF_MONTH,-3);
days=calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);
Date date=calendar.getTime();
System.out.println(date);
}
}
# java比较器
package com.day.controller;
import org.jetbrains.annotations.NotNull;
import java.util.Arrays;
public class Hello{
public static void main(String[] args){
// 对象的正常是比较
// 但是根据某个属性也可以排序
Goods[] goodsArray=new Goods[4];
goodsArray[0]=new Goods(20);
goodsArray[1]=new Goods(10);
goodsArray[2]=new Goods(30);
goodsArray[3]=new Goods(50);
Arrays.sort(goodsArray);
System.out.println(Arrays.toString(goodsArray));
}
}
class Goods implements Comparable {
private double price;
public Goods(double price){
this.price=price;
}
@Override
public String toString() {
return "Goods{" +
"price=" + price +
'}';
}
@Override
public int compareTo(@NotNull Object o) {
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 Doublepare(this.price,goods.price);
}
throw new RuntimeException("传出数据类型不一致");
}
}
# Comparator排序
package com.day.controller;
import java.util.Arrays;
import java.util.Comparator;
public class Hello{
public static void main(String[] args){
// 对象的正常是比较
// 但是根据某个属性也可以排序
Goods[] goodsArray=new Goods[4];
goodsArray[0]=new Goods("笔记本",2000);
goodsArray[1]=new Goods("手机",300);
goodsArray[2]=new Goods("电视",1500);
goodsArray[3]=new Goods("笔记本",5000);
Arrays.sort(goodsArray, new Comparator<Goods>() {
@Override
public int compare(Goods o1, Goods o2) {
if(o1 instanceof Goods && o2 instanceof Goods){
Goods goods1= (Goods) o1;
Goods goods2= (Goods) o2;
if(goods1.getName().equals(goods2.getName())){
return -Doublepare(goods1.getPrice(),goods2.getPrice());
}else{
return goods1.getName()pareTo(goods2.getName());
}
}
throw new RuntimeException("传入数据类型不一致");
}
});
System.out.println(Arrays.toString(goodsArray));
}
}
// 定制排序
class Goods{
private String name;
private double price;
@Override
public String toString() {
return "Goods{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Goods(String name, double price){
this.name=name;
this.price=price;
}
}
# System、Math、BigInteger、BigDecimal
package com.day.controller;
public class Hello{
public static void main(String[] args){
// 立刻退出
// System.exit(0);
// 请求回收
// System.gc();
// 获取属性
// System.out.println(System.getProperty("java.version"));
double number=Math.random();
System.out.println(number);
}
}8、枚举类与注解
（1）枚举类
# 当定义一组常量时，强烈建议使用枚举类，主要用来做信息标志和信息分类
package com.day.controller;
public class Hello{
public static void main(String[] args){
// JDK5.0以后的新特性
State state=State.FIRST_STATUS;
System.out.println(state);
System.out.println(state.getStatus());
state=State.SECOND_STATUS;
System.out.println(state);
System.out.println(state.getStatus());
}
}
enum State{
// 多个对象之前用逗号,末尾的用分号
FIRST_STATUS(1),
SECOND_STATUS(2);
private final int status;
State(int status){
this.status=status;
}
public int getStatus() {
return status;
}
}
# 信息标志和信息分类
package com.day.controller;
public class Hello{
public static void main(String[] args){
// JDK5.0以后的新特性
move(State.FIRST_STATUS);
move(State.MIDDLE_STATUS);
move(State.LAST_STATUS);
}
public static void move(State state){
switch (state){
case FIRST_STATUS:
System.out.println("第一帧");
break;
case MIDDLE_STATUS:
System.out.println("中间帧");
break;
case LAST_STATUS:
System.out.println("最后帧");
break;
}
}
}
enum State{
// 多个对象之前用逗号,末尾的用分号
FIRST_STATUS, MIDDLE_STATUS, LAST_STATUS;
}
（2）注解
# @author 作者信息,多个作者之间逗号分割
# @version 版本信息
# @see 相关主体
# @param 对参数的说明，如果没有参数不能写
# @exception 对方法可能抛出异常进行说明，如果没有throws显示抛出就不能写
# @param @return @exception 只用于方法
package com.day.controller;
public class Hello{
public static void main(String[] args){
@SuppressWarnings("unused")
int number=10;
}
}
class Person{
@SuppressWarnings("unused")
private String name;
@SuppressWarnings("unused")
public Person(){
}
@SuppressWarnings("unused")
public Person(String name) {
this.name = name;
}
public void say(){
System.out.println("人说话");
}
}
interface Info{
void show();
}
@SuppressWarnings("unused")
class Student extends Person implements Info{
@Override
public void say(){
System.out.println("学生说话");
}
@Override
public void show() {
System.out.println("学生展示");
}
}
# 自定义注解
package com.day.controller;
public class Hello{
public static void main(String[] args){
}
}
@interface MyAnnotation{
String value() default "Hello";
}
@MyAnnotation(value="man")
class Person{
}
@MyAnnotation()
class Student{
}
# 元注解
# Retention、Target、Document、Inherited
# JDK8 可重复注解、类型注解
package com.day.controller;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
public class Hello{
public static void main(String[] args){
}
}
@Inherited
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE,FIELD, METHOD, PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
@interface MyAnnotation{
String value() default "Hello";
}
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE,FIELD, METHOD, PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
@interface MyAnnotations{
MyAnnotation[] value();
}
@MyAnnotation(value="man1")
@MyAnnotation(value="man2")
class Person{
}
# 类型注解
package com.day.controller;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
public class Hello{
public static void main(String[] args){
}
}
@Inherited
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE,FIELD, METHOD, PARAMETER,
CONSTRUCTOR,LOCAL_VARIABLE,TYPE_PARAMETER})
@interface MyAnnotation{
String value() default "Hello";
}
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE,FIELD, METHOD, PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
@interface MyAnnotations{
MyAnnotation[] value();
}
@MyAnnotation(value="man1")
@MyAnnotation(value="man2")
class Person<@MyAnnotation T>{
}
# 类型注解
package com.day.controller;
import java.lang.annotation.*;
import java.util.ArrayList;
import static java.lang.annotation.ElementType.*;
public class Hello{
public static void main(String[] args){
}
}
@Inherited
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE,FIELD, METHOD, PARAMETER,
CONSTRUCTOR,LOCAL_VARIABLE,TYPE_PARAMETER,
TYPE_USE})
@interface MyAnnotation{
String value() default "Hello";
}
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE,FIELD, METHOD, PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
@interface MyAnnotations{
MyAnnotation[] value();
}
@MyAnnotation(value="man1")
@MyAnnotation(value="man2")
class Person<@MyAnnotation T>{
public void show(){
ArrayList<@MyAnnotation String> arrayList=new ArrayList<>();
}
}9、集合
# 集合和数组都是对多个数据进行存储的结构，就是java容器
# 都是内存存储。持久化存储（mysql/文件）
# Collection接口 List/Set、Map接口 键值对
（1）Collection方法
package com.day.controller;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
public class Hello{
public static void main(String[] args){
Collection collection=new ArrayList();
collection.add("A");
collection.add("B");
collection.add(123);
collection.add(new Date());
System.out.println(collection.size());
// addAll
Collection collection1=new ArrayList();
collection1.add(4);
collection1.add("C");
collection1.addAll(collection);
System.out.println(collection1.size());
System.out.println(collection1.isEmpty());
collection1.clear();
System.out.println(collection1.isEmpty());
}
}
/*
1.Collection 单列集合 List(动态数组) Set(高中学的集合)
2.Map 双列集合,键值对数据,y=f(x)
*/
# Collection 方法二
package com.day.controller;
import java.util.ArrayList;
import java.util.Collection;
public class Hello{
public static void main(String[] args){
Collection collection=new ArrayList();
collection.add(1);
collection.add(2);
collection.add(new String("tom"));
System.out.println(collection.contains(1));
// 说明判断的是内容,而不是地址,但是如果我们自己对象判断,需要重写equals方法
System.out.println(collection.contains(new String("tom")));
Collection collection1=new ArrayList();
collection1.add(1);
System.out.println(collection.containsAll(collection1));
collection1.add(8);
System.out.println(collection.containsAll(collection1));
}
}
# Collection 方法三
package com.day.controller;
import java.util.ArrayList;
import java.util.Collection;
public class Hello{
public static void main(String[] args){
Collection collection=new ArrayList();
collection.add(1);
collection.add(2);
System.out.println(collection.remove(1));
System.out.println(collection.remove(3));
System.out.println(collection.size());
Collection collection1=new ArrayList();
collection1.add(2);
//System.out.println(collection.removeAll(collection1));
//System.out.println(collection);
System.out.println(collection.retainAll(collection1));
System.out.println(collection);
}
}
# 方法四
package com.day.controller;
import java.util.ArrayList;
import java.util.Collection;
public class Hello{
public static void main(String[] args){
Collection collection=new ArrayList();
collection.add(1);
collection.add(2);
// hash值
System.out.println(collection.hashCode());
// 集合转数组
Object[] objectArray=collection.toArray();
for(Object temp:objectArray){
System.out.println(temp);
}
}
}
# 集合的遍历Iterator
package com.day.controller;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Hello{
public static void main(String[] args){
Collection collection=new ArrayList();
collection.add(1);
collection.add(2);
collection.add("Hello");
// Iterator
Iterator iterator=collection.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
# 增强for循环
package com.day.controller;
import java.util.ArrayList;
import java.util.Collection;
public class Hello{
public static void main(String[] args){
Collection collection=new ArrayList();
collection.add(1);
collection.add(2);
collection.add("Hello");
// foreach,增强for循环
for(Object temp:collection){
System.out.println(temp);
}
}
}
# List接口,动态数组
# ArrayList是线程不安全的（效率高），Vector是线程安全的（效率低）
# LinkedList 双向列表存储，适用于频繁的插入、删除
# ArrayList 方法
package com.day.controller;
import java.util.ArrayList;
public class Hello{
public static void main(String[] args){
ArrayList arrayList=new ArrayList();
arrayList.add(1);
arrayList.add(2);
arrayList.add("tom");
System.out.println(arrayList);
ArrayList arrayList1=new ArrayList();
arrayList1.add("jack");
arrayList1.add("rose");
arrayList1.add(arrayList);
System.out.println(arrayList1);
System.out.println(arrayList1.indexOf("rose"));
}
}
# set接口 无序、不可重复Hashset(线程不安全) LinkedHashSet TreeSet(可以按指定属性排序)
# 无序不等于随机，存储的数据在数组中并非按照数组索引的顺序做的添加。是根据要添加数据的hash值
# 决定的。不可重复是指不能多次添加相同的数据（对象的话，按照equals方法判断时不能返回true,而且要
# 有hashcode的方法），会被覆盖。
# LinkedHashSet，在原有set基础上添加了一对链表
（2）Map接口
package com.day.controller;
import java.util.HashMap;
public class Hello{
public static void main(String[] args){
// 双列数据,key value 键值对
// map中的key是无序的,不可重复的
HashMap hashMap=new HashMap<>();
hashMap.put("1","Hello");
hashMap.put("2","Hi");
hashMap.put("3","Java");
for(Object key:hashMap.keySet()){
System.out.println(key+": "+hashMap.get(key));
}
}
}
# Properties也是Map的实现类
# 这就可以在多个线程中操作这个List
package com.day.controller;
import java.util.*;
public class Hello{
public static void main(String[] args){
List list=new ArrayList();
List myList= Collections.synchronizedList(list);
// myList就是线程安全的
}
}
（3）Java版数据结构简述
数据结构=排兵布阵10、泛型与文件
（1）泛型
package com.day.controller;
import java.util.ArrayList;
public class Hello{
public static void main(String[] args){
ArrayList arrayList=new ArrayList();
// 存放学生的成绩
arrayList.add(68);
arrayList.add(78);
// 类型不安全
arrayList.add("Hello");
for(Object temp:arrayList){
// 强转还报错
System.out.println((int)temp);
}
}
}
# 使用泛型
package com.day.controller;
import java.util.ArrayList;
public class Hello{
public static void main(String[] args){
ArrayList<Integer> arrayList= new ArrayList<>();
arrayList.add(78);
arrayList.add(88);
// 以下这种将不让操作
// arrayList.add("Hello");
for(Integer integer:arrayList){
// 无需强转
System.out.println(integer);
}
}
}
# map用泛型
package com.day.controller;
import java.util.HashMap;
import java.util.Map;
public class Hello{
public static void main(String[] args){
Map<String,Integer> map=new HashMap<String,Integer>();
map.put("tom",78);
map.put("jack",88);
for(String key:map.keySet()){
System.out.println(key+" "+map.get(key));
}
}
}
# 自定义泛型类，子类继承父类的时候也可以像new对象时一样指定数据类型
package com.day.controller;
public class Hello{
public static void main(String[] args){
// 如果定义了泛型类,没有用,则此泛型类型为Object类型
// 不建议这种方法的
//Person person=new Person();
// 指定以后就固定了
Person<String> person=new Person<String>("陈翔",26,"info");
person.setT("change");
}
}
class Person<T>{
String name;
int age;
T t;
public Person(){}
public Person(String name,int age,T t){
this.name=name;
this.age=age;
this.t=t;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
# 泛型不同的引用不能互相赋值
# 泛型方法
package com.day.controller;
import java.util.ArrayList;
import java.util.List;
public class Hello{
public static void main(String[] args){
Integer strArray[]={1,2,3,6,8};
Hello hello=new Hello();
List<Integer> list=hello.arrayToList(strArray);
System.out.println(list);
}
public <E> List<E> arrayToList(E[] arr){
ArrayList<E> arrayList=new ArrayList<>();
for(E e:arr){
arrayList.add(e);
}
return arrayList;
}
}
# 泛型类和方法在BigMapper操作数据库的时候还是非常实用的
# 通配符?的使用
package com.day.controller;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Hello{
public static void main(String[] args){
List<Object> list1=new ArrayList<>();
list1.add("1");
List<String> list2=new ArrayList<>();
list1.add("2");
List<?> list=null;
list=list1;
list=list2;
print(list1);
print(list2);
}
public static void print(List<?> list){
Iterator<?> iterator=list.iterator();
while(iterator.hasNext()){
Object obj=iterator.next();
System.out.println(obj);
}
}
}
（2）IO流
# File类
package com.day.controller;
import java.io.File;
public class Hello{
public static void main(String[] args){
// src/main/resources/Hello.txt
// 相对路径
File file=new File("src/main/resources/Hello.txt");
System.out.println(file.canRead());
}
}
package com.day.controller;
import java.io.File;
public class Hello{
public static void main(String[] args){
File file=new File("src/main/resources/Hello.txt");
System.out.println(file.canRead());
System.out.println(file.getAbsolutePath());
System.out.println(file.getAbsoluteFile());
System.out.println(file.lastModified());
System.out.println(file.getName());
System.out.println(file.getPath());
}
}
# 文件夹文件遍历打印
package com.day.controller;
import java.io.File;
import java.util.Arrays;
import java.util.List;
public class Hello{
public static void main(String[] args){
File file=new File("src/main/resources/");
List<String> fileList= Arrays.asList(file.list());
for(String temp:fileList){
System.out.println(temp);
}
File[] fileArray= file.listFiles();
for(File temp:fileArray){
System.out.println(temp);
}
}
}
# 方法二
package com.day.controller;
import java.io.File;
public class Hello{
public static void main(String[] args){
File file=new File("src/main/resources/");
System.out.println(file.isDirectory());
System.out.println(file.isFile());
System.out.println(file.exists());
System.out.println(file.canRead());
System.out.println(file.canWrite());
System.out.println(file.isHidden());
}
}
# 文件、目录创建与删除
package com.day.controller;
import java.io.File;
import java.io.IOException;
public class Hello{
public static void main(String[] args) throws IOException {
// 创建 删除
File file=new File("src/main/resources/create.txt");
if(!file.exists()){
file.createNewFile();
System.out.println("成功");
}else{
file.delete();
System.out.println("删除");
}
// 目录的创建
File fileDir=new File("src/main/resources/myDir/");
if(!fileDir.exists()){
fileDir.mkdir();
System.out.println("目录创建成功");
}else{
fileDir.delete();
System.out.println("目录删除成功");
}
}
}
# 但是需要读写文件内容，就需要IO流；File类的对象常会作为参数传递到流的构造器中
# 缓冲字节流，能加快字节流读和写的速度。（字符流也可以，但是考虑到图片、音频、视频），都建议以字 # 节流为基础学习这些IO流
package com.day.controller;
import java.io.*;
public class Hello{
public static void main(String[] args){
long startTime=System.currentTimeMillis();
// 1.实例化File类
File srcFile=new File("src/main/resources/ZGL.jpg");
File desFile=new File("src/main/resources/ZGL2.jpg");
// 2.提供FileWriter的对象
FileInputStream fileInputStream = null;
BufferedInputStream bufferedInputStream=null;
FileOutputStream fileOutputStream= null;
BufferedOutputStream bufferedOutputStream=null;
try {
byte[] byteArray=new byte[1024];
int len;
fileInputStream=new FileInputStream(srcFile);
bufferedInputStream=new BufferedInputStream(fileInputStream);
fileOutputStream=new FileOutputStream(desFile,true);
bufferedOutputStream=new BufferedOutputStream(fileOutputStream);
while((len=bufferedInputStream.read(byteArray))!=-1){
bufferedOutputStream.write(byteArray,0,len);
bufferedOutputStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
}finally {
// 关闭外层流,内层流自动关闭
if(bufferedInputStream!=null){
try {
bufferedInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// 关闭外层流,内层流自动关闭
if(bufferedOutputStream!=null){
try {
bufferedOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
long endTime=System.currentTimeMillis();
// 耗时: 20ms
System.out.println("耗时: "+(endTime-startTime)+"ms");
}
}
}
# 字节流转换流，能保证读文本打印到控制台不乱吗，到另一个文本不乱码。以字节流为基础做的操作
# 还可以在字节流转换的基础上，继续包装缓冲流！！！
# BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
package com.day.controller;
import java.io.*;
public class Hello{
public static void main(String[] args){
long startTime=System.currentTimeMillis();
// 1.实例化File类
File srcFile=new File("src/main/resources/Hello.txt");
File desFile=new File("src/main/resources/Hello1.txt");
// 2.提供FileWriter的对象
FileInputStream fileInputStream;
InputStreamReader inputStreamReader=null;
FileOutputStream fileOutputStream;
OutputStreamWriter outputStreamWriter=null;
try {
char[] charArray=new char[1024];
int len;
fileInputStream=new FileInputStream(srcFile);
inputStreamReader=new InputStreamReader(fileInputStream);
fileOutputStream=new FileOutputStream(desFile,true);
outputStreamWriter=new OutputStreamWriter(fileOutputStream);
while((len=inputStreamReader.read(charArray))!=-1){
String temp=new String(charArray,0,len);
System.out.println(temp);
outputStreamWriter.write(temp);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
// 关闭外层流,内层流自动关闭
if(inputStreamReader!=null){
try {
inputStreamReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// 关闭外层流,内层流自动关闭
if(outputStreamWriter!=null){
try {
outputStreamWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
long endTime=System.currentTimeMillis();
// 耗时: 20ms 加缓冲流耗时: 16ms
System.out.println("耗时: "+(endTime-startTime)+"ms");
}
}
}
# 控制台的System.in 标准输入流,从键盘输入
# System.out System.err 标准输出流
package com.day.controller;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Hello{
public static void main(String[] args){
BufferedReader bufferedReader=null;
try {
InputStreamReader inputStreamReader=new InputStreamReader(System.in);
bufferedReader=new BufferedReader(inputStreamReader);
while(true){
System.out.println("请输入字符串,e退出");
String userInput;
userInput = bufferedReader.readLine();
if(userInput.equals("e")){
System.out.println("程序结束...");
break;
}
userInput=userInput.toUpperCase();
System.out.println(userInput);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(bufferedReader!=null){
try {
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
# 数据流—>用来操作基本数据类型和String类型的数据。不如配置文件好用11、对象流与网络编程
（1）对象流
# 序列化 -用ObjectOutputStream类保存基本类型数据多对象的机制
# 反序列化-用ObjectOutputStream类读取基本类型数据多对象的机制
# 对象可以序列化的机制：允许内存中java对象转换成平台无关的二进制流,可以永久保存磁盘或通过网络传输。
# 把实现Serializable接口的对象—>转换为字节数据。
# 基础类
package com.day.controller;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Hello{
public static void main(String[] args) throws Exception {
// 序列化 内存中java对象—>磁盘/网络
ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("object.dat"));
objectOutputStream.writeObject("Hello");
objectOutputStream.flush();
objectOutputStream.close();
// 反序列化 磁盘/网络—>内存中java对象
ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream("object.dat"));
Object object=objectInputStream.readObject();
System.out.println(object.toString());
objectInputStream.close();
}
}
# 自己定义的类，类必须实现Serializable或Externalizable,需要全局常量serialVersionUID（值随意）
# 如果没有定义静态常量，他的值是自动生成的，当我们对这个类修改时，再用原来的还原很可能出现问题。
# 还必须保证其内部所有的属性也是可序列化的，如果Person里再有别的类这时一定要注意！！！
# static和transient修饰的成员变量不能进行序列化。
package com.day.controller;
import java.io.*;
public class Hello{
public static void main(String[] args) throws Exception {
// 序列化 内存中java对象—>磁盘/网络
ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("object.dat"));
objectOutputStream.writeObject(new Person("陈翔"));
objectOutputStream.flush();
objectOutputStream.close();
// 反序列化 磁盘/网络—>内存中java对象
ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream("object.dat"));
Object object=objectInputStream.readObject();
System.out.println(object.toString());
objectInputStream.close();
}
}
class Person implements Serializable {
public static final long serialVersionUID=110161L;
private String name;
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
# RandomAccessFile
package com.day.controller;
import java.io.File;
import java.io.RandomAccessFile;
public class Hello{
public static void main(String[] args) throws Exception {
// 可读入，可以输出，r和rw是模式指定
RandomAccessFile inputRandomAccessFile=new RandomAccessFile(new File("src/main/resources/Hello.txt"),"r");
RandomAccessFile outputRandomAccessFile=new RandomAccessFile(new File("src/main/resources/Hello3.txt"),"rw");
byte[] byteArray=new byte[1024];
int len;
while((len=inputRandomAccessFile.read(byteArray)) != -1){
outputRandomAccessFile.write(byteArray,0,len);
}
inputRandomAccessFile.close();
outputRandomAccessFile.close();
}
}
# 如果文件存在，直接写，会对原文件的内容进行覆盖
# commons.io三方包拷贝引用
package com.day.controller;
import org.apachemons.io.FileUtils;
import java.io.File;
public class Hello{
public static void main(String[] args) throws Exception {
File srcFile=new File("src/main/resources/Hello.txt");
File desFile=new File("src/main/resources/Hello2.txt");
FileUtils.copyFile(srcFile,desFile);
}
}
（2）网络编程
# 网络通信的要素：IP 端口号
# [1]IP地址，唯一标识Internet上的计算机（通信实体）
# [2]本地地址:127.0.0.1与localhost
# [3]公网地址，局域网地址（192.168开头的）
# [4]域名 wdfgdzx.top
package com.day.controller;
import java.InetAddress;
public class Hello{
public static void main(String[] args) throws Exception {
InetAddress inetAddress=InetAddress.getByName("192.168.10.14");
System.out.println(inetAddress);
InetAddress address=InetAddress.getByName("wdfgdzx.top");
System.out.println(address);
}
}
# [5]端口号标识计算机上运行的进程（程序）
# [6]端口号与IP地址的组合得出一个网络套接字：Socket
# 网络协议
[1] TCP/IP协议
[2] Windows查看端口占用和结束端口，netstat -ano |findstr “8829” tskill 576 结束进程
[3] 创建Socket对象,指明服务器端的IP和端口号-服务端指定自己监听的端口号-调用accept接受来自客户端
的socket-获取输入流-读取流中数据-关闭。
package com.day.controller;
import org.junit.Test;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.InetAddress;
import java.ServerSocket;
import java.Socket;
public class Hello{
public static void main(String[] args) throws Exception {
}
// 客户端
@Test
public void client() throws Exception {
InetAddress inetAddress=InetAddress.getByName("127.0.0.1");
Socket socket=new Socket(inetAddress,8089);
OutputStream outputStream=socket.getOutputStream();
outputStream.write("I am 客户端".getBytes());
outputStream.close();
socket.close();
}
// 服务端
@Test
public void server() throws Exception {
ServerSocket serverSocket=new ServerSocket(8089);
Socket socket=serverSocket.accept();
InputStream inputStream=socket.getInputStream();
InputStreamReader inputStreamReader=new InputStreamReader(inputStream);
BufferedReader bufferedReader=new BufferedReader(inputStreamReader);
String temp;
while((temp=bufferedReader.readLine())!=null){
System.out.println(temp);
}
System.out.println("收到消息来自于: "+socket.getInetAddress().getHostAddress());
bufferedReader.close();
inputStreamReader.close();
inputStream.close();
socket.close();
serverSocket.close();
}
}
# 例二发送文件
package com.day.controller;
import org.junit.Test;
import java.io.*;
import java.InetAddress;
import java.ServerSocket;
import java.Socket;
public class Hello{
public static void main(String[] args) throws Exception {
}
// 客户端
@Test
public void client() throws Exception {
InetAddress inetAddress=InetAddress.getByName("127.0.0.1");
Socket socket=new Socket(inetAddress,8089);
OutputStream outputStream=socket.getOutputStream();
// 读本地文件
FileInputStream fileInputStream=new FileInputStream(new File("src/main/resources/Hello.txt"));
byte[] byteArray=new byte[1024];
int len;
while((len=fileInputStream.read(byteArray))!=-1){
// 不断发给网络
outputStream.write(byteArray,0,len);
}
fileInputStream.close();
outputStream.close();
socket.close();
}
// 服务端
@Test
public void server() throws Exception {
ServerSocket serverSocket=new ServerSocket(8089);
Socket socket=serverSocket.accept();
InputStream inputStream=socket.getInputStream();
InputStreamReader inputStreamReader=new InputStreamReader(inputStream);
BufferedReader bufferedReader=new BufferedReader(inputStreamReader);
FileOutputStream fileOutputStream=new FileOutputStream(new File("src/main/resources/accept.txt"));
String temp;
while((temp=bufferedReader.readLine())!=null){
fileOutputStream.write(temp.getBytes());
}
System.out.println("收到文件来自于: "+socket.getInetAddress().getHostAddress());
fileOutputStream.close();
bufferedReader.close();
inputStreamReader.close();
inputStream.close();
socket.close();
serverSocket.close();
}
}
# 例题三 保存并返回给客户端消息
package com.day.controller;
import org.junit.Test;
import java.io.*;
import java.InetAddress;
import java.ServerSocket;
import java.Socket;
public class Hello{
public static void main(String[] args) throws Exception {
}
// 客户端
@Test
public void client() throws Exception {
InetAddress inetAddress=InetAddress.getByName("127.0.0.1");
Socket socket=new Socket(inetAddress,8089);
OutputStream outputStream=socket.getOutputStream();
// 读本地文件
FileInputStream fileInputStream=new FileInputStream(new File("src/main/resources/Hello.txt"));
byte[] byteArray=new byte[1024];
int len;
while((len=fileInputStream.read(byteArray))!=-1){
// 不断发给网络
outputStream.write(byteArray,0,len);
}
// 关闭数据的输出
socket.shutdownOutput();
// 接受服务器消息并显示
InputStream inputStream=socket.getInputStream();
InputStreamReader inputStreamReader=new InputStreamReader(inputStream);
BufferedReader bufferedReader=new BufferedReader(inputStreamReader);
String temp;
while((temp=bufferedReader.readLine())!=null){
System.out.println(temp);
}
bufferedReader.close();
inputStreamReader.close();
inputStream.close();
fileInputStream.close();
outputStream.close();
socket.close();
}
// 服务端
@Test
public void server() throws Exception {
ServerSocket serverSocket=new ServerSocket(8089);
Socket socket=serverSocket.accept();
InputStream inputStream=socket.getInputStream();
InputStreamReader inputStreamReader=new InputStreamReader(inputStream);
BufferedReader bufferedReader=new BufferedReader(inputStreamReader);
FileOutputStream fileOutputStream=new FileOutputStream(new File("src/main/resources/accept.txt"));
String temp;
while((temp=bufferedReader.readLine())!=null){
fileOutputStream.write(temp.getBytes());
}
System.out.println("收到文件来自于: "+socket.getInetAddress().getHostAddress());
OutputStream outputStream=socket.getOutputStream();
outputStream.write("服务器告知接受文件成功...".getBytes());
outputStream.close();
fileOutputStream.close();
bufferedReader.close();
inputStreamReader.close();
inputStream.close();
socket.close();
serverSocket.close();
}
}
# URL编程，统一资源定位符，相当于种子，访问服务器的资源
package com.day.controller;
import java.URL;
public class Hello{
public static void main(String[] args) throws Exception {
URL url=new URL("http://wdfgdzx.top/");
System.out.println(url.getProtocol());
System.out.println(url.getHost());
System.out.println(url.getPort());
System.out.println(url.getPath());
System.out.println(url.getFile());
}
}
# 通过URL下载文件
package com.day.controller;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.HttpURLConnection;
import java.URL;
public class Hello{
public static void main(String[] args) throws Exception {
URL url=new URL("http://wdfgdzx.top:8001/client/favicon.ico");
HttpURLConnection httpURLConnection= (HttpURLConnection) url.openConnection();
httpURLConnection.connect();
InputStream inputStream=httpURLConnection.getInputStream();
FileOutputStream fileOutputStream=new FileOutputStream("src/main/resources/favicon.ico");
byte[] byteArray=new byte[1024];
int len;
while((len=inputStream.read(byteArray))!=-1){
fileOutputStream.write(byteArray,0,len);
}
// 关闭流
fileOutputStream.close();
inputStream.close();
httpURLConnection.disconnect();
}
}12、反射
（1）反射操作类的实例化、私有属性、方法
package com.day.controller;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Hello{
public static void main(String[] args) throws Exception {
}
// 反射
@Test
public void getClassInstance() throws Exception {
Class clazz=Person.class;
Constructor constructor=clazz.getConstructor(String.class,int.class);
constructor.setAccessible(true);
Person person= (Person) constructor.newInstance("陈翔",12);
System.out.println(person);
Field age=clazz.getDeclaredField("age");
age.setAccessible(true);
age.set(person,10);
System.out.println(person);
Method method=clazz.getDeclaredMethod("setAge", int.class);
method.setAccessible(true);
method.invoke(person,8);
System.out.println(person);
}
}
class Person{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void say(){
System.out.println("Hello");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
# 怎么看待私有化和反射，私有化只是建议使用的方式
# 开发中使用哪种方式实例化，大部分是new，少数如需动态性会使用，如网络编程
（2）关于Class类的理解
# 类加载的过程：程序经过javac.exe命令以后，会生成一个或多个字节码文件（.class）—>用java.exe命令
# 对某个字节码文件解释运行。相当于把某个字节码文件加载到内存中，此过程就称为类的加载。—>
# 加载到内存中的类，我们就称为运行时类，就作为Class的一个实例！！！
（3）获取Class实例的四种方式
package com.day.controller;
import org.junit.Test;
public class Hello{
public static void main(String[] args) throws Exception {
}
// 反射
@Test
public void getClassInstance() throws Exception {
//方式一 .class
Class clazz=Person.class;
System.out.println(clazz);
//方式二 getClass()
Person person=new Person("",1);
clazz=person.getClass();
System.out.println(clazz);
//方式三 forName(String classPath)
clazz=Class.forName("com.day.controller.Person");
System.out.println(clazz);
//方式四 了解接口
ClassLoader classLoader=Hello.class.getClassLoader();
clazz=classLoader.loadClass("com.day.controller.Person");
System.out.println(clazz);
}
}
class Person{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void say(){
System.out.println("Hello");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
# ClassLoader
package com.day.controller;
import org.junit.Test;
public class Hello{
public static void main(String[] args) throws Exception {
}
// 反射
@Test
public void classLoader() throws Exception {
ClassLoader classLoader=Hello.class.getClassLoader();
System.out.println(classLoader);
classLoader=classLoader.getParent();
System.out.println(classLoader);
// getParent无法获取引导类加载器
// 它主要负责加载java的核心类库,无法加载自定义的
classLoader=classLoader.getParent();
System.out.println(classLoader);
}
}
# 读取配置文件
package com.day.controller;
import org.junit.Test;
import java.io.InputStream;
import java.util.Properties;
public class Hello{
public static void main(String[] args) throws Exception {
}
// 反射
@Test
public void myTest() throws Exception {
//方式一
/*Properties properties=new Properties();
FileInputStream fileInputStream=new FileInputStream("src/main/resources/jdbc.properties");
properties.load(fileInputStream);
System.out.println(properties.getProperty("user"));
System.out.println(properties.getProperty("password"));*/
//方式二
ClassLoader classLoader=Hello.class.getClassLoader();
// 路径默认是src下面的
InputStream inputStream =classLoader.getResourceAsStream("jdbc.properties");
Properties properties=new Properties();
properties.load(inputStream);
System.out.println(properties.getProperty("user"));
System.out.println(properties.getProperty("password"));
}
}
（4）通过反射创建运行时类的对象
package com.day.controller;
import org.junit.Test;
public class Hello{
public static void main(String[] args) throws Exception {
}
// 反射
@Test
public void myTest() throws Exception {
Class<Person> clazz=Person.class;
Person person= clazz.newInstance();
// newInstance()调用此方法,创建对应的运行时类的对象
// 必须要有空参构造器,且权限足够才能调用newInstance方法
System.out.println(person);
}
}
class Person{
private String name;
public Person(){
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
'}';
}
}
（5）举例体会反射的动态性
package com.day.controller;
import java.util.Random;
public class Hello{
public static void main(String[] args) throws Exception {
for(int i=0;i<50;i++) {
int num = new Random().nextInt(3);// 0 1 2
String classPath = "";
switch (num) {
case 0:
classPath = "java.util.Date";
break;
case 1:
classPath = "java.lang.Object";
break;
case 2:
classPath = "com.day.controller.Person";
break;
}
Object object = myTest(classPath);
System.out.println(object);
}
}
// 此方法可以创建一个指定类的对象
// classPath指定类的全类名
public static Object myTest(String classPath) throws Exception {
// 这种方式最常用
Class clazz=Class.forName(classPath);
return clazz.newInstance();
}
}
class Person{
private String name;
public Person(){
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
'}';
}
}
（6）反射获取运行时类的属性结构、方法结构、构造器结构
package com.day.controller;
import java.lang.reflect.Field;
public class Hello{
public String name;
public static void main(String[] args) throws Exception {
Class clazz=Hello.class;
// 当前运行时类及父类声明为public访问权限的属性
Field[] fieldArray=clazz.getFields();
for(Field field:fieldArray){
System.out.println(field);
}
// 自己定义的属性
clazz.getDeclaredFields();
}
}
# 方法结构
package com.day.controller;
import java.lang.reflect.Method;
public class Hello{
public static void main(String[] args) throws Exception {
Class clazz=Hello.class;
// 获取当前运行类及其父类中声明public权限的方法
Method[] methodArray =clazz.getMethods();
for(Method method:methodArray){
System.out.println(method);
}
// 当前运行类中所有的方法,不包含父类
clazz.getDeclaredMethods();
}
}
# 构造器结构
package com.day.controller;
import java.lang.reflect.Constructor;
public class Hello{
public static void main(String[] args) throws Exception {
Class clazz=Hello.class;
// 获取构造器结构
Constructor[] constructorArray=clazz.getConstructors();
for(Constructor constructor:constructorArray){
System.out.println(constructor);
}
}
}
# 反射还可以获取运行时类的接口、所在包、注解等
（7）反射的应用-动态代理
# 静态代理，代理类和被代理类在编译期间就确定下来了
package com.day.controller;
public class Hello{
public static void main(String[] args) throws Exception {
// 代理类决定要不要创建对象,何时创建,何时调用方法
// 大代理
Nike nike=new Nike();
ProxyFactory proxyFactory=new ProxyFactory(nike);
proxyFactory.product();
}
}
interface Factory{
void product();
}
//代理类
class ProxyFactory implements Factory{
private Factory factory;
public ProxyFactory(Factory factory){
this.factory=factory;
}
@Override
public void product() {
System.out.println("代理准备工作...");
factory.product();
System.out.println("代理工作收尾...");
}
}
//被代理类
class Nike implements Factory{
@Override
public void product() {
System.out.println("Nike生产...");
}
}
# 动态代理
package com.day.controller;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Hello{
public static void main(String[] args) throws Exception {
// 代理类决定要不要创建对象,何时创建,何时调用方法
BeProxyHuman beProxyHuman=new BeProxyHuman();
// 代理类的对象
Human human= (Human) ProxyFactory.getProxyInstance(beProxyHuman);
System.out.println(human.belief());
human.eat("地锅鸡");
Nike nike=new Nike();
Factory factory= (Factory) ProxyFactory.getProxyInstance(nike);
factory.product();
}
}
interface Human{
String belief();
void eat(String food);
}
interface Factory{
void product();
}
// 被代理类
class Nike implements Factory{
@Override
public void product() {
System.out.println("Nike生产...");
}
}
class BeProxyHuman implements Human{
@Override
public String belief() {
return "信仰";
}
@Override
public void eat(String food) {
System.out.println("我喜欢吃"+food);
}
}
// 1.如何动态创建代理类及其对象
// 2.当通过代理类对象调用方法,如果调用被代理类中的方法。
class ProxyFactory{
public static Object getProxyInstance(Object object){
MyInvocationHandler myInvocationHandler=new MyInvocationHandler();
myInvocationHandler.bind(object);
return Proxy.newProxyInstance(object.getClass().getClassLoader(),
object.getClass().getInterfaces(),
myInvocationHandler);
}
}
class MyInvocationHandler implements InvocationHandler{
private Object object;//使用被代理对象赋值
//当我们通过代理类的对象,调用方法时,会自动调如下方法invoke()
//将被代理类要执行的方法a的功能声明在invoke中
public void bind(Object object){
this.object=object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 这个方法很关键
Object returnObject=method.invoke(object,args);
// 上述方法的返回值就作为invoke的方法的返回值。
return returnObject;
}
}
# 进一步优化AOP
package com.day.controller;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Hello{
public static void main(String[] args) throws Exception {
// 代理类决定要不要创建对象,何时创建,何时调用方法
BeProxyHuman beProxyHuman=new BeProxyHuman();
// 代理类的对象
Human human= (Human) ProxyFactory.getProxyInstance(beProxyHuman);
System.out.println(human.belief());
human.eat("地锅鸡");
Nike nike=new Nike();
Factory factory= (Factory) ProxyFactory.getProxyInstance(nike);
factory.product();
}
}
interface Human{
String belief();
void eat(String food);
}
interface Factory{
void product();
}
// 被代理类
class Nike implements Factory{
@Override
public void product() {
System.out.println("Nike生产...");
}
}
class BeProxyHuman implements Human{
@Override
public String belief() {
return "信仰";
}
@Override
public void eat(String food) {
System.out.println("我喜欢吃"+food);
}
}
class HumanUtil{
public void commonMethod1(){
System.out.println("通用方法1...");
}
public void commonMethod2(){
System.out.println("通用方法2...");
}
}
// 1.如何动态创建代理类及其对象
// 2.当通过代理类对象调用方法,如果调用被代理类中的方法。
class ProxyFactory{
public static Object getProxyInstance(Object object){
MyInvocationHandler myInvocationHandler=new MyInvocationHandler();
myInvocationHandler.bind(object);
return Proxy.newProxyInstance(object.getClass().getClassLoader(),
object.getClass().getInterfaces(),
myInvocationHandler);
}
}
class MyInvocationHandler implements InvocationHandler{
private Object object;//使用被代理对象赋值
//当我们通过代理类的对象,调用方法时,会自动调如下方法invoke()
//将被代理类要执行的方法a的功能声明在invoke中
public void bind(Object object){
this.object=object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
HumanUtil humanUtil=new HumanUtil();
humanUtilmonMethod1();
// 这个方法很关键
Object returnObject=method.invoke(object,args);
humanUtilmonMethod2();
// 上述方法的返回值就作为invoke的方法的返回值。
return returnObject;
}
}13、JAVA8新特性
（1）Lambda表达式
# 对原来代码的更改
package com.day.controller;
import java.util.Comparator;
public class Hello{
public static void main(String[] args) throws Exception {
Runnable runnable=new Runnable() {
@Override
public void run() {
System.out.println("我爱我家");
}
};
runnable.run();
System.out.println("*************使用Lambda****************");
Runnable runnable1=() -> {
System.out.println("用Lambda我爱我家");
};
runnable1.run();
Comparator<Integer> comparator=new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integerpare(o1,o2);
}
};
System.out.println(comparatorpare(12,18));
Comparator<Integer> comparator1=(o1,o2) -> Integerpare(o1,o2);
System.out.println("*************使用Lambda****************");
System.out.println(comparator1pare(12,18));
}
}
# 6种方式
package com.day.controller;
import java.util.Comparator;
import java.util.function.Consumer;
public class Hello{
public static void main(String[] args) throws Exception {
// 举例 (o1,o2) -> Integerpare(o1,o2)
// 箭头左边是形参列表(抽象方法的形参列表),右边是Lambda体(抽象方法的方法重写)
// 1.无参,无返回值
// 大括号包括的是方法体
Runnable runnable=() -> {
System.out.println("我爱我家");
};
runnable.run();
// lambda表达式的本质:就是作为接口的实例(对象)
// 2.需要一个参数,没有返回值
Consumer<String> consumer=(String str) -> {
System.out.println("我爱我家"+str);
};
consumer.accept("热烈的...");
// 3.数据类型可以省略,基于编译器推出,称为类型推断
Consumer<String> consumer1=(str) -> {
System.out.println("类型推断-我爱我家"+str);
};
consumer1.accept("疯狂的");
// 4.若lambda只要一个餐宿,小括号也可以省略
Consumer<String> consumer2=str -> {
System.out.println("无小括号-我爱我家"+str);
};
consumer2.accept("永久的");
// 5.两个以上的参数,多条执行语句,可以有返回值
Comparator<Integer> comparator=(o1,o2) -> {
System.out.println("o1为: "+o1);
System.out.println("o2为: "+o2);
if(o1pareTo(o2)>0){
System.out.println("o1大于o2");
}else if(o1pareTo(o2)==0){
System.out.println("o1等于o2");
}else{
System.out.println("o1小于o2");
}
return o1pareTo(o2);
};
comparatorpare(12,19);
// 6.当Lambda体只有一条语句是,return与大括号也可以省略
Comparator<Integer> comparator1=(o1,o2) -> o1pareTo(o2);
System.out.println(comparator1pare(12,13));
}
}
// 总结
// 左边:Lambda形参列表的类型可以省略
// 右边:Lambda体,正常应该有{}大括号包着,如果只有一条return {}都可以省略
// 针对函数式接口,只能有一个抽象方法
// # 函数式接口的介绍
package com.day.controller;
public class Hello{
public static void main(String[] args) throws Exception {
}
}
// 自定义函数式接口
// Lambda表达式就是一个函数式接口的实例
@FunctionalInterface
interface MyInterface{
void method();
}
# 另一个例子
package com.day.controller;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
public class Hello{
public static void main(String[] args) {
//四大核心函数式接口
// 消费性接口 Consumer<T> void accept(T t)
// 供给型 Supplier<T> T get()
// 函数型接口 Function<T,R> R apply(T t)
// 断定性接口 Predicate<T> boolean test(T t)
happyTime(500, new Consumer<Double>() {
@Override
public void accept(Double aDouble) {
System.out.println("有点累,去买东西吃,花了"+aDouble);
}
});
happyTime(300,money -> System.out.println("有点累,去旅游,花了"+money));
List<String> list= Arrays.asList("北京","上海","合肥","西安","南京");
List<String> returnList=filterStr(list, new Predicate<String>() {
@Override
public boolean test(String s) {
return s.contains("京");
}
});
System.out.println(returnList);
List<String> returnList1=filterStr(list,s -> s.contains("京"));
System.out.println(returnList1);
}
public static void happyTime(double money, Consumer<Double> consumer){
consumer.accept(money);
}
public static List<String> filterStr(List<String> list, Predicate<String> predicate){
ArrayList<String> tempList=new ArrayList<>();
for(String str:list){
if(predicate.test(str)){
tempList.add(str);
}
}
return tempList;
}
}
// (2)方法引用的使用
package com.day.controller;
import java.util.function.Consumer;
import java.util.function.Supplier;
public class Hello{
public static void main(String[] args) {
// 方法引用是Lambda表达式的深层表达
// 1.使用的情境:当传递给Lambda体的操作,已经有方法实现了,可以使用方法引用
Consumer<String> consumer=str -> System.out.println(str);
consumer.accept("北京");
System.out.println("*************方法引用**************");
// 使用格式 类/对象 :: 方法名
Consumer<String> consumer1=System.out :: println;
consumer1.accept("北京");
Employee employee=new Employee("陈翔");
Supplier<String> supplier=() -> employee.getName();
System.out.println(supplier.get());
System.out.println("*************方法引用**************");
Supplier<String> supplier1=employee :: getName;
System.out.println(supplier1.get());
}
}
class Employee{
private String name;
public Employee(String name){
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// 构造器引用与数据引用的使用
package com.day.controller;
import java.util.function.Function;
import java.util.function.Supplier;
public class Hello{
public static void main(String[] args) {
Supplier<Employee> supplier= new Supplier<Employee>() {
@Override
public Employee get() {
return new Employee("蘑菇头");
}
};
System.out.println("************************************");
Supplier<Employee> supplier1=() -> new Employee("陈翔");
System.out.println("************************************");
Supplier<Employee> supplier2=Employee :: new;
Employee employee=supplier2.get();
Function<String,Employee> function=Employee :: new;
Employee employee1=function.apply("TOM");
}
}
class Employee{
private String name;
public Employee(){
System.out.println("1被调用了...");
}
public Employee(String name){
System.out.println("2被调用了...");
this.name=name;
}
}
// (3)强大的Stream API
package com.day.controller;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;
public class Hello{
public static void main(String[] args) {
// 1.很好的解决了对集合数据的操作
// 2.Mysql Oracle ,而MongDB Redis这些NoSQL就需要java层面去处理
// 3.Stream与CPU打交道,是计算;集合是存储,与内存打交道
// 4.创建-中间操作-终止操作
// 第一种创建
ArrayList<Employee> employeeArrayList=new ArrayList<>();
Stream<Employee> employeeStream=employeeArrayList.stream();
// 并行
employeeStream=employeeArrayList.parallelStream();
// 第二种
String[] myArray=new String[10];
Stream<String> stringStream=Arrays.stream(myArray);
// 第三种
Stream<Integer> integerStream=Stream.of(1,2,3,4,5,6);
// 第四种,无限流
Stream.iterate(0,t -> t+2).limit(10).forEach(System.out::println);
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}
}
class Employee{
private String name;
public Employee(String name){
this.name=name;
}
}
// 强大的Stream API-筛选与切片
package com.day.controller;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class Hello{
public static void main(String[] args) {
// filter
String[] myArray={"马云","刘强东","马化腾","沈腾","阿里云","马丽","刘强东","刘强东","刘强东","刘强东"};
List<String> strList= Arrays.asList(myArray);
Stream<String> stringStream=strList.stream();
stringStream.filter(s -> s.contains("马")).forEach(System.out::println);
System.out.println("***********************");
strList.stream().filter(s -> s.contains("马")).limit(2).forEach(System.out::println);
System.out.println("***********************");
strList.stream().filter(s -> s.contains("马")).skip(2).forEach(System.out::println);
System.out.println("***********************");
strList.stream().filter(s -> s.contains("刘")).distinct().forEach(System.out::println);
}
}
class Employee{
private String name;
public Employee(String name){
this.name=name;
}
}
// 强大的Stream API-映射
package com.day.controller;
import java.util.Arrays;
import java.util.List;
public class Hello{
public static void main(String[] args) {
// map
String[] myArray={"马云","刘强东","马化腾","沈腾","阿里云","马丽","刘强东"};
List<String> stringList= Arrays.asList(myArray);
stringList.stream().map(str -> str+"---").forEach(System.out::println);
}
}
// 强大的Stream API-排序-重要对比较也有了新的认识
package com.day.controller;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class Hello{
public static void main(String[] args) {
// map
Integer[] myArray={1,16,80,0,100,52,631};
List<Integer> integerList= Arrays.asList(myArray);
integerList.stream().sorted().forEach(System.out::println);
Person person=new Person("aaa",1);
Person person1=new Person("ccc",3);
Person person2=new Person("bbb",2);
Person person3=new Person("zzz",4);
List<Person> personList=new ArrayList<>();
personList.add(person);
personList.add(person1);
personList.add(person2);
personList.add(person3);
personList.stream().sorted().forEach(System.out::println);
}
}
// 不实现Comparable,不能进行正常的排序
class Person implements Comparable {
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
@Override
public int compareTo(@NotNull Object o) {
if (o instanceof Person) {
Person person = (Person) o;
return this.namepareTo(person.name);
}
throw new RuntimeException("传出数据类型不一致");
}
}
// 强大的Stream API-匹配与查找
package com.day.controller;
import org.jetbrains.annotations.NotNull;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
public class Hello{
public static void main(String[] args) {
// map
Integer[] myArray={1,16,80,0,100,52,631};
List<Integer> integerList=Arrays.asList(myArray);
boolean allMatch=integerList.stream().allMatch(e -> e > 18);
System.out.println(allMatch);
boolean allMatch1=integerList.stream().allMatch(e -> e >= 0);
System.out.println(allMatch1);
System.out.println("*********************************");
allMatch=integerList.stream().noneMatch(e -> e<2);
System.out.println(allMatch);
allMatch=integerList.stream().noneMatch(e -> e<0);
System.out.println(allMatch);
System.out.println("*********************************");
Optional<Integer> optionalInteger=integerList.stream().findFirst();
System.out.println(optionalInteger);
// 24集9分钟
System.out.println("*********************************");
Stream<Integer> integerStream=integerList.stream().map(e -> e);
System.out.println(integerStream.max(Integer :: compare));
}
}
// 不实现Comparable,不能进行正常的排序
class Person implements Comparable {
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
@Override
public int compareTo(@NotNull Object o) {
if (o instanceof Person) {
Person person = (Person) o;
return this.namepareTo(person.name);
}
throw new RuntimeException("传出数据类型不一致");
}
}
// 强大的Stream API-规约、收集
package com.day.controller;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Hello{
public static void main(String[] args) {
List<Integer> integerList=Arrays.asList(1,2,3,5,7,1,3,8);
System.out.println(integerList.stream().reduce(0,Integer::sum));
System.out.println("*********************************");
Person person=new Person("a",2000);
Person person1=new Person("b",3000);
List<Person> employeeList= new ArrayList<>();
employeeList.add(person);
employeeList.add(person1);
List<Person> personList=employeeList.stream().filter(e -> e.getAge() > 1500).collect(Collectors.toList());
personList.forEach(System.out::println);
}
}
// 不实现Comparable,不能进行正常的排序
class Person implements Comparable {
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
@Override
public int compareTo(@NotNull Object o) {
if (o instanceof Person) {
Person person = (Person) o;
return this.namepareTo(person.name);
}
throw new RuntimeException("传出数据类型不一致");
}
}
// (4) Optional类
package com.day.controller;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
public class Hello{
public static void main(String[] args) {
// 1.空指针是导致java应用程序失败的最常见原因。
// 2.Optional<T>类是一个容器类,可以避免空指针异常
/*Girl girl=new Girl("Rose");
girl=null;
Optional<Girl> girlOptional=Optional.of(girl);*/
Girl girl=new Girl("Rose");
// girl=null;
// ofNullable可以传空的
Optional<Girl> girlOptional=Optional.ofNullable(girl);
System.out.println(girlOptional);
}
}
class Boy{
private Girl girl;
public Boy(Girl girl) {
this.girl = girl;
}
public Girl getGirl() {
return girl;
}
public void setGirl(Girl girl) {
this.girl = girl;
}
@Override
public String toString() {
return "Boy{" +
"girl=" + girl +
'}';
}
}
class Girl{
private String name;
public Girl(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Girl{" +
"name='" + name + ''' +
'}';
}
}
// (4) Optional类-使用举例
package com.day.controller;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
public class Hello{
public static void main(String[] args) {
Boy boy=new Boy();
// boy=null;
String girlName=getGirlName(boy);
System.out.println(girlName);
}
public static String getGirlName(Boy boy){
// return boy.getGirl().getName();
// 原来避免就需要用非空判断
// 用Optional
Optional<Boy> boyOptional=Optional.ofNullable(boy);
Boy boy1=boyOptional.orElse(new Boy(new Girl("杨幂")));
Girl girl=boy1.getGirl();
Optional<Girl> girlOptional=Optional.ofNullable(girl);
girl=girlOptional.orElse(new Girl("默认的女生"));
return girl.getName();
}
}
class Boy{
private Girl girl;
public Boy(){
}
public Boy(Girl girl) {
this.girl = girl;
}
public Girl getGirl() {
return girl;
}
public void setGirl(Girl girl) {
this.girl = girl;
}
@Override
public String toString() {
return "Boy{" +
"girl=" + girl +
'}';
}
}
class Girl{
private String name;
public Girl(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Girl{" +
"name='" + name + ''' +
'}';
}
}14、JAVA9/10/11特性
// (1) JDK版本更新的说明
package com.day.controller;
public class Hello{
public static void main(String[] args) {
// JDK 9 10 11
// 8 -> 11即可
// 11的下载
Person person=new Person();
System.out.println(person);
// JAVA 9
// 模块化
// REPL工具 jshell
// 钻石操作符
// try结构的语法升级,自动关闭的资源可以放到try(xxx){}里,不能更改
// String底层存储结构的变更
// 创建只读集合
// InputStream中的transferTo()方法
// 增强的StreamAPI
// Optional的新方法
// 引擎升级 Nashorn,可以用来解析ECMAScript的JS脚本
// JAVA 10
// 局部变量类型推断
// int a=10;
// var a=10; 在10里可以用
// var list= new ArrayList<Integer>();
// 感觉var也会是过渡
// 创建不可变集合的方法
// JDK 11 是一个长期支持的版本
// 两种新的GC
// String中新增的方法
// isBlank() strip() trim()
// Optional加强
// isEmpty
// 局部变量类型推断的升级
// HttpClient全新的Http客户端
// 更简化的编译运行程序
// java Hello.java 可以这么写...
// 废弃的Nashorn引擎
// ZGC
// JAVA的两大利器 JVM GCC
// 新Epsilon垃圾收集器
// JDK中还有哪些不足?
// JSON API
// 货币的API
}
}
class Person{
}