学习笔记--＞Java02
JAVA学习目录
- 知识点
- 面向对象（下）
-
- static
- 单例的实现（一个类只能被调用一次）
- 代码块
- 关键字-final
- abstrct
- interface
- 内部类的使用
- 异常处理
- 高级（调api，完成多个功能应用）
-
- 多线程
-
- 实现总结
- 进程生命周期
- 线程安全
-
- 1.同步机制
- 线程的通信
- Java常用类
-
- String内存
- String方法
- String习题
- StringBuffer,StringBuilder
- Date
- Java比较器
- System，Math类
- 枚举类&注解
-
- 注解
- Java集合
-
- Collection
- List接口（三个）
- Set
- Map
- collections，Arrays（带s的是）工具类coolection创建集合的接口
- 复习
- 数据结构
- 泛型
- IO流
- 网络编程
-
- IP和端口号
- Java反射机制
371-405没看
知识点
- 数据类型转化
面向对象（下）
static
单例的实现（一个类只能被调用一次）
package com.atguigu.java2;
/*
* 单例设计模式：
* 1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
*
* 2. 如何实现？
* 饿汉式 vs 懒汉式
*
* 3. 区分饿汉式 和 懒汉式
* 饿汉式：
* 坏处：对象加载时间过长。
* 好处：饿汉式是线程安全的
*
* 懒汉式：好处：延迟对象的创建。
* 目前的写法坏处：线程不安全。--->到多线程内容时，再修改
*
*
*/
public class SingletonTest1 {
public static void main(String[] args) {
// Bank bank1 = new Bank();
// Bank bank2 = new Bank();
Bank bank1 = Bank.getInstance();
Bank bank2 = Bank.getInstance();
System.out.println(bank1 == bank2);
}
}
//饿汉式
class Bank{
//1.私有化类的构造器
private Bank(){
}
//2.内部创建类的对象
//4.要求此对象也必须声明为静态的
private static Bank instance = new Bank();
//3.提供公共的静态的方法，返回类的对象
public static Bank getInstance(){
return instance;
}
}
package com.atguigu.java2;
/*
* 单例模式的懒汉式实现
*
*/
public class SingletonTest2 {
public static void main(String[] args) {
Order order1 = Order.getInstance();
Order order2 = Order.getInstance();
System.out.println(order1 == order2);
}
}
class Order{
//1.私有化类的构造器
private Order(){
}
//2.声明当前类对象，没有初始化
//4.此对象也必须声明为static的
private static Order instance = null;
//3.声明public、static的返回当前类对象的方法
public static Order getInstance(){
if(instance == null){
instance = new Order();
}
return instance;
}
}
代码块
package com.atguigu.java3;
/*
* 类的成员之四：代码块（或初始化块）
*
* 1. 代码块的作用：用来初始化类、对象
* 2. 代码块如果有修饰的话，只能使用static.
* 3. 分类：静态代码块 vs 非静态代码块
*
* 4. 静态代码块
* >内部可以有输出语句
* >随着类的加载而执行,而且只执行一次
* >作用：初始化类的信息
* >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
* >静态代码块的执行要优先于非静态代码块的执行
* >静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
*
* 5. 非静态代码块
* >内部可以有输出语句
* >随着对象的创建而执行
* >每创建一个对象，就执行一次非静态代码块
* >作用：可以在创建对象时，对对象的属性等进行初始化
* >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
* >非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
*
*/
public class BlockTest {
public static void main(String[] args) {
String desc = Person.desc;
System.out.println(desc);
Person p1 = new Person();
Person p2 = new Person();
System.out.println(p1.age);
Person.info();
}
}
class Person{
//属性
String name;
int age;
static String desc = "我是一个人";
//构造器
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//非static的代码块
{
System.out.println("hello, block - 2");
}
{
System.out.println("hello, block - 1");
//调用非静态结构
age = 1;
eat();
//调用静态结构
desc = "我是一个爱学习的人1";
info();
}
//static的代码块
static{
System.out.println("hello,static block-2");
}
static{
System.out.println("hello,static block-1");
//调用静态结构
desc = "我是一个爱学习的人";
info();
//不可以调用非静态结构
// eat();
// name = "Tom";
}
//方法
public void eat(){
System.out.println("吃饭");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public static void info(){
System.out.println("我是一个快乐的人！");
}
}
关键字-final
abstrct
abstract类时中可以写抽象方法，但抽象方法是不能写方法体的(应用：当我们不确定方法体该如何写时)，可以通过用子类的继承，然后在子类中进行方法的重写
比如：父类中的abstract findArea（）是不确定的，在调用子类时，根据子类创建的子类1重写abstract findArea（）方法来（求圆，求方形）。
前面讲的匿名类，是指没有创建类的对象时没有进行显示的赋上类名，
这里的类的匿名子类对象，是针对抽象类使用，因为抽象类不能被new，只能被子类extends，
但也可可以被如下方法调用，但必须要重写abrasct方法
interface
一个子类只有一个父类，但可以有多个interface
infterface必须经过类的对象，也就是封装到类中才能调用
package com.atguigu.java1;
/*
* 接口的使用
* 1.接口使用interface来定义
* 2.Java中，接口和类是并列的两个结构
* 3.如何定义接口：定义接口中的成员
*
* 3.1 JDK7及以前：只能定义全局常量和抽象方法
* >全局常量：public static final的.但是书写时，可以省略不写
* >抽象方法：public abstract的
*
* 3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）
*
* 4. 接口中不能定义构造器的！意味着接口不可以实例化
*
* 5. Java开发中，接口通过让类去实现(implements)的方式来使用.
* 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
* 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
*
* 6. Java类可以实现多个接口 --->弥补了Java单继承性的局限性
* 格式：class AA extends BB implements CC,DD,EE
*
* 7. 接口与接口之间可以继承，而且可以多继承
*
* *******************************
* 8. 接口的具体使用，体现多态性
* 9. 接口，实际上可以看做是一种规范
*
* 面试题：抽象类与接口有哪些异同？
*
*/
public class InterfaceTest {
public static void main(String[] args) {
System.out.println(Flyable.MAX_SPEED);
System.out.println(Flyable.MIN_SPEED);
// Flyable.MIN_SPEED = 2;
Plane plane = new Plane();
plane.fly();
}
}
interface Flyable{
//全局常量
public static final int MAX_SPEED = 7900;//第一宇宙速度
int MIN_SPEED = 1;//省略了public static final
//抽象方法
public abstract void fly();
//省略了public abstract
void stop();
//Interfaces cannot have constructors
// public Flyable(){
//
// }
}
interface Attackable{
void attack();
}
class Plane implements Flyable{
@Override
public void fly() {
System.out.println("通过引擎起飞");
}
@Override
public void stop() {
System.out.println("驾驶员减速停止");
}
}
abstract class Kite implements Flyable{
@Override
public void fly() {
}
}
class Bullet extends Object implements Flyable,Attackable,CC{
@Override
public void attack() {
// TODO Auto-generated method stub
}
@Override
public void fly() {
// TODO Auto-generated method stub
}
@Override
public void stop() {
// TODO Auto-generated method stub
}
@Override
public void method1() {
// TODO Auto-generated method stub
}
@Override
public void method2() {
// TODO Auto-generated method stub
}
}
//************************************
interface AA{
void method1();
}
interface BB{
void method2();
}
interface CC extends AA,BB{
}
接口的多态性
package com.atguigu.java1;
/*
* 接口的使用
* 1.接口使用上也满足多态性
* 2.接口，实际上就是定义了一种规范
* 3.开发中，体会面向接口编程！
*
*/
public class USBTest {
public static void main(String[] args) {
Computer com = new Computer();
//1.创建了接口的非匿名实现类的非匿名对象
Flash flash = new Flash();
com.transferData(flash);
//2. 创建了接口的非匿名实现类的匿名对象
com.transferData(new Printer());
//3. 创建了接口的匿名实现类的非匿名对象
USB phone = new USB(){
@Override
public void start() {
System.out.println("手机开始工作");
}
@Override
public void stop() {
System.out.println("手机结束工作");
}
};
com.transferData(phone);
//4. 创建了接口的匿名实现类的匿名对象
com.transferData(new USB(){
@Override
public void start() {
System.out.println("mp3开始工作");
}
@Override
public void stop() {
System.out.println("mp3结束工作");
}
});
}
}
class Computer{
public void transferData(USB usb){//USB usb = new Flash();
usb.start();
System.out.println("具体传输数据的细节");
usb.stop();
}
}
interface USB{
//常量：定义了长、宽、最大最小的传输速度等
void start();
void stop();
}
class Flash implements USB{
@Override
public void start() {
System.out.println("U盘开启工作");
}
@Override
public void stop() {
System.out.println("U盘结束工作");
}
}
class Printer implements USB{
@Override
public void start() {
System.out.println("打印机开启工作");
}
@Override
public void stop() {
System.out.println("打印机结束工作");
}
}
内部类的使用
package com.atguigu.java2;
/*
* 类的内部成员之五：内部类
* 1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
*
* 2.内部类的分类：成员内部类（静态、非静态） vs 局部内部类(方法内、代码块内、构造器内)
*
* 3.成员内部类：
* 一方面，作为外部类的成员：
* >调用外部类的结构
* >可以被static修饰
* >可以被4种不同的权限修饰
*
* 另一方面，作为一个类：
* > 类内可以定义属性、方法、构造器等
* > 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
* > 可以被abstract修饰
*
*
* 4.关注如下的3个问题
* 4.1 如何实例化成员内部类的对象
* 4.2 如何在成员内部类中区分调用外部类的结构
* 4.3 开发中局部内部类的使用 见《InnerClassTest1.java》
*
*/
public class InnerClassTest {
public static void main(String[] args) {
//创建Dog实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();
dog.show();
//创建Bird实例(非静态的成员内部类):
// Person.Bird bird = new Person.Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird();
bird.sing();
System.out.println();
bird.display("黄鹂");
}
}
class Person{
String name = "小明";
int age;
public void eat(){
System.out.println("人：吃饭");
}
//静态成员内部类
static class Dog{
String name;
int age;
public void show(){
System.out.println("卡拉是条狗");
// eat();
}
}
//非静态成员内部类
class Bird{
String name = "杜鹃";
public Bird(){
}
public void sing(){
System.out.println("我是一只小小鸟");
Person.this.eat();//调用外部类的非静态属性
eat();
System.out.println(age);
}
public void display(String name){
System.out.println(name);//方法的形参
System.out.println(this.name);//内部类的属性
System.out.println(Person.this.name);//外部类的属性
}
}
public void method(){
//局部内部类
class AA{
}
}
{
//局部内部类
class BB{
}
}
public Person(){
//局部内部类
class CC{
}
}
}
异常处理
高级（调api，完成多个功能应用）
多线程
创建4种，解决安全3种
打开360就是一个进行，同时用360进行扫描，清垃圾，查文件 就是多线程
每个线程都有独立的栈和程序计数器，多个线程共享一个方法区和堆
package atguigu.java;
/**
* 多线程的创建，方式一：继承于Thread类
* 1. 创建一个继承于Thread类的子类
* 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
* 3. 创建Thread类的子类的对象
* 4. 通过此对象调用start()
*
* 例子：遍历100以内的所有的偶数
*
* @author shkstart
* @create 2019-02-13 上午 11:46
*/
//1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
//2. 重写Thread类的run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3. 创建Thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()
t1.start();
//问题一：我们不能通过直接调用run()的方式启动线程。
// t1.run();
//问题二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程去执行。会报IllegalThreadStateException
// t1.start();
//我们需要重新创建一个线程的对象
MyThread t2 = new MyThread();
t2.start();
//如下操作仍然是在main线程中执行的。
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i + "***********main()************");
}
}
}
}
## 匿名子类的方法
new Thread(){
public void run(){
for (int j=0; j<=100;j++){
if(j%2==1){
System.out.println(Thread.currentThread().getName()+"***"+j);
}
}}}.start();
要是getName（）所在的类是Thread时，可以直接调用getName()实现线程的查看
其他就是Thread.currentThread().setName("主线程");
1.对象中的调用
Mythread2 thread2 =new Mythread2();
thread2.setName("线程二");
2.main中的调用
Thread.currentThread().setName("主线程");
System.out.println(Thread.currentThread().getPriority());
3.run()方法体中的调用
public void run(){
while (true){
if(tickets>0){
System.out.println(getName()+":票号为："+tickets);
实现总结
1.Thread类的继承 2.使用Runnable的接口
//法一：
class Window extends Thread{
private static int tickets =100;
public void run(){
while (true){
if(tickets>0){
System.out.println(getName()+":票号为："+tickets);
tickets--;}
else{
break;
}
}
}
}
//使用
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
System.out.println(w1.getPriority());
System.out.println(w2.getPriority());
System.out.println(w3.getPriority());
w1.start();
w2.start();
w3.start();
//法二
class Run1 implements Runnable{
private int tickets =100;
public void run(){
while (true){
if (tickets>0){
System.out.println(Thread.currentThread().getName()+"卖票："+tickets);
tickets--;
}else{
break;
}
}
}
}
Run1 r =new Run1();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
Thread t3 = new Thread(r);
t1.setName("窗口1：");
t2.setName("窗口2：");
t3.setName("窗口3：");
//法三 实现Callable接口
package com.linyang;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
*创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
* 1. call()可以有返回值的。
* 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
* 3. Callable是支持泛型的
*
* 实现
* 1.创建一个实现Callable的实现类
* 2.实现call方法，将此线程需要执行的操作声明在call()中
* 3.创建Callable接口实现类的对象
* 4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
* 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
* 6.获取Callable中call方法的返回值
* 7.get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
* /
class NumThread implements Callable{
@Override
public 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){
NumThread numThread = new NumThread();
FutureTask futureTask = new FutureTask(numThread);
new Thread(futureTask).start();
try {
Object sum = futureTask.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
法四、线程池
package com.linyang;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
* @author linyang
* @create 2021-08-03-11:11
*/
class NumberThread implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public 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. 提供指定线程数量的线程池(设置线程池的属性)
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
//3.关闭连接池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
System.out.println(service.getClass());
service1.setCorePoolSize(15);
// service1.setKeepAliveTime(10);
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread());
// service.submit(Callable callable);//适合使用于Callable
service.shutdown();
}
}
进程生命周期
线程安全
1.同步机制
每个线程都有独立的栈和程序计数器，多个线程共享一个方法区和堆
public static 可以保证多个子类共用一个数据
//1同步代码块
public void run(){
while (true){
//show();
synchronized (this){
if (tickets>0){
try{Thread.sleep(100);}
catch (InterruptedException e){
e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+"卖票："+tickets);
tickets--;
}else{
break;
}
}}
}
//2同步方法解决Runnable多线程不安全
private synchronized void show(){//同步监视器：this 可以不写
if (tickets>0){
try{Thread.sleep(100);}
catch (InterruptedException e){
e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+"卖票："+tickets);
tickets--;
}else{
break;
}
}
//3.对于继承Thread类来讲，最后会建多个对象，就不能保证同一个锁
private synchronized void show(){//同步监视器：this 可以不写
可以加一个static表示唯一。
//3.lock锁
class Run2 implements Runnable{
private int tickets =100;
private ReentrantLock lock =new ReentrantLock();
public void run(){
while (true){
try{
lock.lock();
if (tickets>0){
try{Thread.sleep(100);}
catch (InterruptedException e){
e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+"卖票："+tickets);
tickets--;
}else{
break;
}
}finally {
lock.unlock();//
}
}
}
}
死锁
当有多个锁时，一个先拿a，再拿b，一个先拿b，再拿a，两者互相占据资源等待对方释放，就会产生死锁。
线程的通信
Java常用类
String内存
String方法
==注意 ==
- 字符串的不可变性，且字符串在常量池是唯一一份的，只要str不同，就用不同地址表示。
s2在s1上操作时，s1是不变的，s2单独开辟空间 - String substring(int beginIndex, int endIndex) --左开右闭
- String 严格区分大小写
- String replace(char oldChar, char newChar)所有的str都替换
/*
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)：比较两个字符串的大小，从左到右单个字符的ascll码进行比较大小，然后s1-s2，返回值为正负，只
要找到对比的不是0，就停止搜索
String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
*/
@Test
public void test2() {
String s1 = "HelloWorld";
String s2 = "helloworld";
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));
String s3 = "abc";
String s4 = s3.concat("def");
System.out.println(s4);
String s5 = "abc";
String s6 = new String("abe");
System.out.println(s5.compareTo(s6));//涉及到字符串排序
String s7 = "北京尚硅谷教育";
String s8 = s7.substring(2);
System.out.println(s7);
System.out.println(s8);
String s9 = s7.substring(2, 5);
System.out.println(s9);
}
@Test
public void test1() {
String s1 = "HelloWorld";
System.out.println(s1.length());
System.out.println(s1.charAt(0));
System.out.println(s1.charAt(9));
// System.out.println(s1.charAt(10));
// s1 = "";
System.out.println(s1.isEmpty());
String s2 = s1.toLowerCase();
System.out.println(s1);//s1不可变的，仍然为原来的字符串
System.out.println(s2);//改成小写以后的字符串
String s3 = " he llo world ";
String s4 = s3.trim();
System.out.println("-----" + s3 + "-----");
System.out.println("-----" + s4 + "-----");
}
}
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
*/
@Test
public void test3(){
String str1 = "hellowworld";
boolean b1 = str1.endsWith("rld");
System.out.println(b1);
boolean b2 = str1.startsWith("He");
System.out.println(b2);
boolean b3 = str1.startsWith("ll",2);
System.out.println(b3);
String str2 = "wor";
System.out.println(str1.contains(str2));
System.out.println(str1.indexOf("lol"));
System.out.println(str1.indexOf("lo",5));
String str3 = "hellorworld";
System.out.println(str3.lastIndexOf("or"));
System.out.println(str3.lastIndexOf("or",6));
//什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？
//情况一：存在唯一的一个str。情况二：不存在str
}
替换：
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个，如果超过了，剩下的全部都放到最后一个元素中。
*/
@Test
public void test4(){
String str1 = "北京尚硅谷教育北京";
String str2 = str1.replace('北', '东');
System.out.println(str1);
System.out.println(str2);
String str3 = str1.replace("北京", "上海");
System.out.println(str3);
System.out.println("*************************");
String str = "12hello34world5java7891mysql456";
//把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
System.out.println(string);
System.out.println("*************************");
str = "12345";
//判断str字符串中是否全部有数字组成，即有1-n个数字组成
boolean matches = str.matches("\\d+");
System.out.println(matches);
String tel = "0571-4534289";
//判断这是否是一个杭州的固定电话
boolean result = tel.matches("0571-\\d{7,8}");
System.out.println(result);
System.out.println("*************************");
str = "hello|world|java";
String[] strs = str.split("\\|");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
System.out.println();
str2 = "hello.world.java";
String[] strs2 = str2.split("\\.");
for (int i = 0; i < strs2.length; i++) {
System.out.println(strs2[i]);
}
}
只要 其中有一个是变量，结果就相当 于一个new的过程（在堆中），然后在常量池中找str
String习题
StringBuffer,StringBuilder
/*
StringBuffer的常用方法：
StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：删除指定位置的内容
StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
StringBuffer insert(int offset, xxx)：在指定位置插入xxx
StringBuffer reverse() ：把当前字符序列逆转
public int indexOf(String str)
public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串
public int length()
public char charAt(int n )
public void setCharAt(int n ,char ch)
总结：
增：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()
*/
@Test
public void test2(){
StringBuffer s1 = new StringBuffer("abc");
s1.append(1);
s1.append('1');
System.out.println(s1);
// s1.delete(2,4);
// s1.replace(2,4,"hello");
// s1.insert(2,false);
// s1.reverse();
String s2 = s1.substring(1, 3);
System.out.println(s1);
System.out.println(s1.length());
System.out.println(s2);
}
Date
470, 480-488没看
long time = System.currentTimeMillis();
//返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
//称为时间戳
System.out.println(time);
Java比较器
492-493没看懂
System，Math类
枚举类&注解
由于Season的构造器是private,所以通过new Season()用构造器是不行的，因此里面又定义了一个public创建的多个对象，在main函数中通过Season.SPRING的方法调用对象。
//自定义枚举类
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()
@Override
public String toString() {
return "Season{" +
"seasonName='" + seasonName + '\'' +
", seasonDesc='" + seasonDesc + '\'' +
'}';
}
}
emum Season{}
package com.atguigu.java;
/**
* 使用enum关键字定义枚举类
* 说明：定义的枚举类默认继承于java.lang.Enum类
*
* @author shkstart
* @create 2019 上午 10:35
*/
public class SeasonTest1 {
public static void main(String[] args) {
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]);
values[i].show();
}
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);
winter.show();
}
}
interface Info{
void show();
}
//使用enum关键字枚举类
enum Season1 implements Info{
//1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
SPRING("春天","春暖花开"){
@Override
public void show() {
System.out.println("春天在哪里？");
}
},
SUMMER("夏天","夏日炎炎"){
@Override
public void show() {
System.out.println("宁夏");
}
},
AUTUMN("秋天","秋高气爽"){
@Override
public void show() {
System.out.println("秋天不回来");
}
},
WINTER("冬天","冰天雪地"){
@Override
public void show() {
System.out.println("大约在冬季");
}
};
//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;
}
// //4.其他诉求1：提供toString()
//
// @Override
// public String toString() {
// return "Season1{" +
// "seasonName='" + seasonName + '\'' +
// ", seasonDesc='" + seasonDesc + '\'' +
// '}';
// }
// @Override
// public void show() {
// System.out.println("这是一个季节");
// }
}
注解
/**
* 注解的使用
*
* 1. 理解Annotation:
* ① jdk 5.0 新增的功能
*
* ② Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation,
* 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。
*
* ③在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android
* 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗
* 代码和XML配置等。
*
* 2. Annocation的使用示例
* 示例一：生成文档相关的注解
* 示例二：在编译时进行格式检查(JDK内置的三个基本注解)
@Override: 限定重写父类方法, 该注解只能用于方法
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
@SuppressWarnings: 抑制编译器警告
* 示例三：跟踪代码依赖性，实现替代配置文件功能
*
* 3. 如何自定义注解：参照@SuppressWarnings定义
* ① 注解声明为：@interface
* ② 内部定义成员，通常使用value表示
* ③ 可以指定成员的默认值，使用default定义
* ④ 如果自定义注解没有成员，表明是一个标识作用。
如果注解有成员，在使用注解时，需要指明成员的值。
自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
自定义注解通过都会指明两个元注解：Retention、Target
4. jdk 提供的4种元注解
元注解：对现有的注解进行解释说明的注解
Retention：指定所修饰的 Annotation 的生命周期：SOURCE\CLASS（默认行为）\RUNTIME
只有声明为RUNTIME生命周期的注解，才能通过反射获取。
Target:用于指定被修饰的 Annotation 能用于修饰哪些程序元素
*******出现的频率较低*******
Documented:表示所修饰的注解在被javadoc解析时，保留下来。
Inherited:被它修饰的 Annotation 将具有继承性。
5.通过反射获取注解信息 ---到反射内容时系统讲解
6. jdk 8 中注解的新特性：可重复注解、类型注解
6.1 可重复注解：① 在MyAnnotation上声明@Repeatable，成员值为MyAnnotations.class
② MyAnnotation的Target和Retention等元注解与MyAnnotations相同。
6.2 类型注解：
ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）。
ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
*
* @author shkstart
* @create 2019 上午 11:37
*/
public class AnnotationTest {
public static void main(String[] args) {
Person p = new Student();
p.walk();
Date date = new Date(2020, 10, 11);
System.out.println(date);
@SuppressWarnings("unused")
int num = 10;
// System.out.println(num);
@SuppressWarnings({ "unused", "rawtypes" })
ArrayList list = new ArrayList();
}
@Test
public void testGetAnnotation(){
Class clazz = Student.class;
Annotation[] annotations = clazz.getAnnotations();
for(int i = 0;i < annotations.length;i++){
System.out.println(annotations[i]);
}
}
}
//jdk 8之前的写法：
//@MyAnnotations({@MyAnnotation(value="hi"),@MyAnnotation(value="hi")})
@MyAnnotation(value="hi")
@MyAnnotation(value="abc")
class Person{
private String name;
private int age;
public Person() {
}
@MyAnnotation
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@MyAnnotation
public void walk(){
System.out.println("人走路");
}
public void eat(){
System.out.println("人吃饭");
}
}
interface Info{
void show();
}
class Student extends Person implements Info{
@Override
public void walk() {
System.out.println("学生走路");
}
public void show() {
}
}
class Generic<@MyAnnotation T>{
public void show() throws @MyAnnotation RuntimeException{
ArrayList<@MyAnnotation String> list = new ArrayList<>();
int num = (@MyAnnotation int) 10L;
}
}
Java集合
Collection
Collection要兼顾list，set所以有些方法list，set单独有，见下。
New ArrayList()的调用及iterator的遍历
public class Test3 {
public static void main(String [] args){
Collection coll =new ArrayList();//存储一个个对象
coll.add("AA");
coll.add(124);//这里把整数自动装箱成Integer类
coll.add(new Object());
coll.add(new String("Tom"));
Collection coll1 =new ArrayList();//存储一个个对象
coll1.add("cc");
coll.addAll(coll1);
System.out.println(coll.size());
System.out.println(coll);//[AA, 124, java.lang.Object@1540e19d, cc]
// 向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().
//1.contains(Object obj):判断当前集合中是否包含obj
//我们在判断时会调用obj对象所在类的equals()。那么这里又考察了equal，没重写时equal就是’==‘，重写后比较的就是类的实体
System.out.println(coll.contains(new String("Tom")));//true,因为String重写了equal
// System.out.println(coll.contains(new Person("Jerry",20)));//false,因为没有重写就相当于比较地址，所以false
System.out.println(coll.contains("124"));//"124"是一个String类，上面的是Integer类，所以返回false
System.out.println(coll.containsAll(coll1));
// coll.clear();
System.out.println(coll.isEmpty());
//2.boolean remove(Object obj),也是先看看是有contains才能remove
Collection coll3 =new ArrayList();
coll3.add(1);
coll3.add(2);
coll3.add(3);
coll3.add(4);
Collection coll4 =new ArrayList();
coll4.add(1);
coll4.add(2);
// coll3.remove(3);//将3拿到手，去cool3中进行比较，然后删除
// coll3.removeAll(coll4);//差集，每次从coo4中拿一个，去删除
coll3.retainAll(coll4);//交集输出[1,2]
System.out.println(coll3);
//3.equals()因为Array.List()是有序的，所以两个集合的前后顺序要一样
coll3.equals(coll4);
//4.
System.out.println(coll3.hashCode());
//5集合->数组
Object [] arr=coll4.toArray();
System.out.println(Arrays.toString(arr));
//6
List<String> list =Arrays.asList(new String[]{"1","2b"});
System.out.println(list);//[1, 2b]
List<int[]> list2 =Arrays.asList(new int []{1,2});
System.out.println(list2);//[[I@677327b6]
//7 Iterator iterator=coll3.iterator();用iterator()方法返回Iterator对象
System.out.println(coll3);//[1,2]
Iterator iterator=coll3.iterator();
// System.out.println(iterator.next());//1
// System.out.println(iterator.next());//2
while(iterator.hasNext()){
System.out.println(iterator.next());//1
Object obj =iterator.next();//2
if(obj.equals("tom")){
iterator.remove();
}
}
}
}
List接口（三个）
从查找角度来看，ArrayList的复杂度O(1)直接通过下标定位，但是删除时为O（n）需要将后面的数据前移
Linkedlist查找时O（N）,删除时为o（1）
注意集合中存放的都是Object，所以在删除时要list.remove(new Integer(15))，对于string是正常list.remove(“a”)
void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
remove(1):删除的是索引为1的数据
remove(new Integer(1))删除的是object
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
总结：常用方法
增：add(Object obj)
删：remove(int index) / remove(Object obj)
对于string是正常list.remove("a"); list.remove(new Integer(15));
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()返回存储元素的个数，而不是底层new（10）的10个空的数组
遍历：① Iterator迭代器方式
② 增强for循环
③ 普通的循环
//方式一：Iterator迭代器方式
Iterator iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("***************");
//方式二：增强for循环
for(Object obj : list){
System.out.println(obj);
}
System.out.println("***************");
//方式三：普通for循环
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
//int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1.
int index = list.indexOf(4567);
System.out.println(index);
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
System.out.println(list.lastIndexOf(456));
//Object remove(int index):移除指定index位置的元素，并返回此元素
Object obj = list.remove(0);
System.out.println(obj);
System.out.println(list);
//Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1,"CC");
System.out.println(list);
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
List subList = list.subList(2, 4);
System.out.println(subList);
System.out.println(list);
Set
哈希值就是调用类的hashcode方法计算的.哈希值不一样，只是取模后得到的值是一样的，要放到同一个位置 上
- 不同数值的哈希值 可能一样
- 一个数据只能有一个哈希值
Map
map接口对应的实现类
五、Map中定义的方法：
添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合
*总结：常用方法：
* 添加：put(Object key,Object value)
* 删除：remove(Object key)
* 修改：put(Object key,Object value)
* 查询：get(Object key)
* 长度：size()
* 遍历：keySet() / values() / entrySet()
*
*
* @author shkstart
* @create 2019 上午 11:15
*/
public class MapTest {
/*
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合
*/
@Test
public void test5(){
Map map = new HashMap();
map.put("AA",123);
map.put(45,1234);
map.put("BB",56);
//遍历所有的key集：keySet()
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println();
//遍历所有的value集：values()
Collection values = map.values();
for(Object obj : values){
System.out.println(obj);
}
System.out.println();
//遍历所有的key-value
//方式一：entrySet()
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
//entrySet集合中的元素都是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "---->" + entry.getValue());
}
System.out.println();
//方式二：
Set keySet = map.keySet();
Iterator iterator2 = keySet.iterator();
while(iterator2.hasNext()){
Object key = iterator2.next();
Object value = map.get(key);
System.out.println(key + "=====" + value);
}
}
/*
元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
*/
@Test
public void test4(){
Map map = new HashMap();
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
// Object get(Object key)
System.out.println(map.get(45));
//containsKey(Object key)
boolean isExist = map.containsKey("BB");
System.out.println(isExist);
isExist = map.containsValue(123);
System.out.println(isExist);
map.clear();
System.out.println(map.isEmpty());
}
/*
添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
*/
@Test
public void test3(){
Map map = new HashMap();
//添加
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
//修改
map.put("AA",87);
System.out.println(map);
Map map1 = new HashMap();
map1.put("CC",123);
map1.put("DD",123);
map.putAll(map1);
System.out.println(map);
//remove(Object key)
Object value = map.remove("CC");
System.out.println(value);
System.out.println(map);
//clear()
map.clear();//与map = null操作不同
System.out.println(map.size());
System.out.println(map);
}
@Test
public void test2(){
Map map = new HashMap();
map = new LinkedHashMap();
map.put(123,"AA");
map.put(345,"BB");
map.put(12,"CC");
System.out.println(map);
}
@Test
public void test1(){
Map map = new HashMap();
// map = new Hashtable();
map.put(null,123);
}
}
collections，Arrays（带s的是）工具类coolection创建集合的接口
因为ArrayList的线程是不安全的，但通常我们要使用，所以使用List list1 = Collections.synchronizedList(list)转为安全的
mport java.util.ArrayList;
import java.util.Ar
rays;
import java.util.Collections;
import java.util.List;
/**
* Collections:操作Collection、Map的工具类
*
*
* 面试题：Collection 和 Collections的区别？
*
*
* @author shkstart
* @create 2019 下午 4:19
*/
public class CollectionsTest {
/*
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 对象的所有旧值
*/
@Test
public void test2(){
List list = new ArrayList();
list.add(123);
list.add(43);
list.add(765);
list.add(-97);
list.add(0);
//报异常：IndexOutOfBoundsException("Source does not fit in dest")
// List dest = new ArrayList();
// Collections.copy(dest,list);
//正确的：
List dest = Arrays.asList(new Object[list.size()]);
System.out.println(dest.size());//list.size();
Collections.copy(dest,list);
System.out.println(dest);
/*
Collections 类中提供了多个 synchronizedXxx() 方法，
该方法可使将指定集合包装成线程同步的集合，从而可以解决
多线程并发访问集合时的线程安全问题
*/
//返回的list1即为线程安全的List
List list1 = Collections.synchronizedList(list);
}
@Test
public void test1(){
List list = new ArrayList();
list.add(123);
list.add(43);
list.add(765);
list.add(765);
list.add(765);
list.add(-97);
list.add(0);
System.out.println(list);
// Collections.reverse(list);
// Collections.shuffle(list);
// Collections.sort(list);
// Collections.reverse(list);
// Collections.swap(list,1,2);
int frequency = Collections.frequency(list, 123);
System.out.println(list);
System.out.println(frequency);
}
}
复习
集合中存的是Object
数据结构
泛型
569-582没看
**
//问题一：类型不安全
//问题二：强转时，可能出现ClassCastException
so引入范型
泛型的类型必须是类，不能是基本数据类型。
- 之所以可以加<>，前提是你创建此方法的时候定义了范型public class ArrayList extends AbstractList**
* 泛型的使用
* 1.jdk 5.0新增的特性
*
* 2.在集合中使用泛型：
* 之所以可以加<>，前提是你创建此方法的时候定义了范型public class ArrayList<E> extends AbstractList<E>
* 总结：
* ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
* ② 在实例化集合类时，可以指明具体的泛型类型
* ③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。
* 比如：add(E e) --->实例化以后：add(Integer e)
* ④ 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
* ⑤ 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。
*
* 3.如何自定义泛型结构：泛型类、泛型接口；泛型方法。见 GenericTest1.java
*
//问题一：类型不安全
//问题二：强转时，可能出现ClassCastException
//在集合中使用泛型的情况：以ArrayList为例
@Test
public void test2(){
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(78);
list.add(87);
//编译时，就会进行类型检查，保证数据的安全
// 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);
}
}
//在集合中使用泛型的情况：以HashMap为例
@Test
public void test3(){
// Map map = new HashMap();
//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);
}
}
}
IO流
594-619没看
站在内存的角度，看数据是输入还是输出
public class Test6 {
public static void main(String[] args) throws IOException {
//一、读入
//1.File类的实例化
File file = new File("E:\\LINYANG\\java_code\\workspace_idea\\JavaSenior\\day01\\src\\hello.txt");//"day09\\hello.txt"
System.out.println(file.getAbsolutePath());
//2.提供具体的流
FileReader fr =new FileReader(file);
//3从硬盘读入到内存(站在内存的角度)
//3.1返回读入的一个字符。如果达到文件末尾，返回-1
// int data = fr.read();
// while (data!=-1){
// System.out.println(data);
// System.out.print((char)data);//调用一次fr.read()就读一个数据，所以要循环的调用
// data =fr.read();
// }
//txt-------Helloworld123
//3.1返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
char [] cbuffer =new char[5];
int len;
while ((len =fr.read(cbuffer))!=-1){
//System.out.print(len);5,5,3,-1
for(int i =0;i<len;i++){//for(int i =0;i
System.out.print(cbuffer[i]);
}
}
//4.流的关闭，否则内存泄露
fr.close();
//二、从内存中写出数据到硬盘的文件里。
// 说明：
// 1. 输出操作，对应的File可以不存在的。并不会报异常
// 2.
// File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
// File对应的硬盘中的文件如果存在：
// 如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖
// 如果流使用的构造器是：FileWriter(file,true):在原有文件基础上追加内容
File file1 =new File("hello1.txt");
System.out.println(file1.getAbsolutePath());
FileWriter fw = new FileWriter(file1,false);
fw.write("I have a dream\n");
fw.write("you need a dream too");
fw.close();
FileReader fr1 =new FileReader(file1);
int data=fr1.read();
while (data!=-1){
System.out.print((char)data);
data = fr1.read();
}
fr1.close();
// 测试FileInputStream和FileOutputStream的使用
// 结论：
// 1. 对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理
// 2. 对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,...)，使用字节流处理
//三、使用8位字节流读txt，若txt都是字母是可以读出，要是有中文就会乱码
System.out.println("******************************");
File srcFile = new File("11.png");
File destFile = new File("点赞.jpg");
//
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//复制的过程
byte[] buffer = new byte[5];
int len2;
while((len2 = fis.read(buffer)) != -1){
fos.write(buffer,0,len2);//每次写入的数量是0-len2，前面读一次是5个，最后就是len个
// System.out.println(new String(buffer,0,len));
}
fis.close();
fos.close();
}
}
网络编程
624-633没看
IP和端口号
package com.atguigu.java1;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* 一、网络编程中有两个主要的问题：
* 1.如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
* 2.找到主机后如何可靠高效地进行数据传输
*
* 二、网络编程中的两个要素：
* 1.对应问题一：IP和端口号
* 2.对应问题二：提供网络通信协议：TCP/IP参考模型（应用层、传输层、网络层、物理+数据链路层）
*
*
* 三、通信要素一：IP和端口号
*
* 1. IP:唯一的标识 Internet 上的计算机（通信实体）
* 2. 在Java中使用InetAddress类代表IP
* 3. IP分类：IPv4 和 IPv6 ; 万维网 和 局域网
* 4. 域名: www.baidu.com www.mi.com www.sina.com www.jd.com
* www.vip.com
* 5. 本地回路地址：127.0.0.1 对应着：localhost
*
* 6. 如何实例化InetAddress:两个方法：getByName(String host) 、 getLocalHost()
* 两个常用方法：getHostName() / getHostAddress()
*
* 7. 端口号：正在计算机上运行的进程。
* 要求：不同的进程有不同的端口号
* 范围：被规定为一个 16 位的整数 0~65535。
*
* 8. 端口号与IP地址的组合得出一个网络套接字：Socket
*/
public class InetAddressTest {
public static void main(String[] args) {
try {
//File file = new File("hello.txt");
InetAddress inet1 = InetAddress.getByName("192.168.10.14");
System.out.println(inet1);
InetAddress inet2 = InetAddress.getByName("www.atguigu.com");
System.out.println(inet2);
InetAddress inet3 = InetAddress.getByName("127.0.0.1");
System.out.println(inet3);
//获取本地ip
InetAddress inet4 = InetAddress.getLocalHost();
System.out.println(inet4);
//getHostName()
System.out.println(inet2.getHostName());
//getHostAddress()
System.out.println(inet2.getHostAddress());
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}
```
### 网络协议
```java
package linyang;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @author linyang
* @create 2021-08-10-10:58
*/
public class Test1
{public static void main(String [] args) throws IOException {
InetAddress inet1 = InetAddress.getByName("192.168.10.14");
System.out.println(inet1);
//1.实例化InetAddress
//InetAddress inet2 = InetAddress.getByName("www.atguigu.com");
InetAddress inet2 = InetAddress.getLocalHost();
System.out.println(inet2);//www.atguigu.com/119.84.129.201
//2.两个常用方法
System.out.println(inet2.getHostName());//www.atguigu.com
System.out.println(inet2.getHostAddress());//119.84.129.201
System.out.println("*************************************************************");
Test1 test=new Test1();
test.server();
//1.创建Socket对象，指明服务器端的ip和端口号
InetAddress inet =InetAddress.getLocalHost();
Socket socket = new Socket(inet,8899);
//2.获取一个输出流，用于输出数据
OutputStream os = socket.getOutputStream();
//3.写出数据的操作
os.write("你好，我是客户1".getBytes());
//4.资源的关闭
// os.close();
}
public void server() throws IOException {
//1.创建服务器端的ServerSocket，指明自己的端口号
ServerSocket ss = new ServerSocket(8899);
//2.调用accept()表示接收来自于客户端的socket
Socket socket1 = ss.accept();
//3.获取输入流
InputStream is = socket1.getInputStream();
//4.读取输入流中的数据
ByteArrayOutputStream 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("收到来自于："+socket1.getInetAddress().getHostAddress()+"的信息");
// baos.close();
}
}
Java反射机制
//
