API专题

概述

一切可以调用的都是API

目的

学习java里提供的各种工具类的使用（工具类提供的构造方法，普通方法，成员变量）

学习工具

api手册

Object

概述

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

常用方法

 System.out.println( o.hashCode() );//返回该对象的哈希码值。-- 哈希码值理解为编号
 ​
 System.out.println( o.toString() );//返回该对象的字符串表示
 ​
 System.out.println( o );//对象在内存中的地址值
 ​
 System.out.println( o.equals(123) );//指示其他某个对象是否与此对象“相等”。

总结

--toString--默认使用的是Object的toString（）展示的是地址值，如果想要属性值就要进行重写

--重写equals--默认使用的是Object的equals（）展示的是地址值之间的比较，不想比较地址值，想比较属性值

--自动生成--generate....

instanceof java里的关键字，通常用来判断obj instanceof student obj是不是学生类型。

string

概述

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。

常用方法

 char charAt(int index)
 ​
 •     返回指定索引处的 char 值。
 ​
 • String concat(String str)
 ​
 •     将指定字符串连接到此字符串的结尾。
 ​
 • boolean contains(CharSequence s)
 ​
 •     当且仅当此字符串包含指定的 char 值序列时，返回 true。
 ​
 • boolean endsWith(String suffix)
 ​
 •     测试此字符串是否以指定的后缀结束。
 ​
 • boolean equals(Object anObject)
 ​
 •     将此字符串与指定的对象比较。
 ​
 • byte[] getBytes()
 ​
 • int hashCode()
 ​
 •     返回此字符串的哈希码。
 ​
 • int indexOf(String str)
 ​
 •     返回指定子字符串在此字符串中第一次出现处的索引。
 ​
 boolean isEmpty()
 ​
 •     当且仅当 length() 为 0 时返回 true。
 ​
 • int length()
 ​
 •     返回此字符串的长度。
 ​
 • int lastIndexOf(String str)
 ​
 •     返回指定子字符串在此字符串中最右边出现处的索引。
 ​
 String replace(char oldChar, char newChar)
 ​
 用新的代替旧的
 ​
 • String[] split(String regex)
 ​
 •     根据给定正则表达式的匹配拆分此字符串。
 ​
 • boolean startsWith(String prefix)
 ​
 •     测试此字符串是否以指定的前缀开始。
 ​
 • String substring(int beginIndex)
 ​
 •     返回一个新的字符串，它是此字符串的一个子字符串。
 ​
 • String substring(int beginIndex, int endIndex)
 ​
 •     返回一个新字符串，它是此字符串的一个子字符串。
 ​
 • char[] toCharArray()
 ​
 •     将此字符串转换为一个新的字符数组。
 ​
 • String toLowerCase()   全部转换为小写
 ​
 • String toUpperCase()   全部转换为大写
 ​
 String trim()
 ​
 •     返回字符串的副本，忽略前导空白和尾部空白。
 ​
 • static String valueOf(int i)
 ​
 •     返回 int 参数的字符串表示形式。

StringBuilder/StringBuffer

概述

都是用来进行字符串拼接的优化方案

常用方法

 StringBuilder append(string b)

包装类

概述

为了对应的基本类型提供丰富的方法

基本类型 byte short int long float double char boolean

包装类型 Byte Short Integer Long Float Double Character Boolean

Number

--提供将表示的数值转换为 byte、double、float、int、long 和 short 的方法。

integer

创建对象

Integer(int value)

常用方法

 int intValue()
 ​
 •     以 int 类型返回该 Integer 的值。
 ​
 • static int parseInt(String s)
 ​
 •     将字符串参数作为有符号的十进制整数进行解析。
 ​
 • static Integer valueOf(int i)
 ​
 •     返回一个表示指定的 int 值的 Integer 实例。
 ​
 

日期类

概述

类 Date 表示特定的瞬间，精确到毫秒

创建对象

Date()

常用方法

  getXxx()
 ​
 System.out.println( d.getTime() );//从1970,1,1 零点到现在的毫秒值
 ​
 System.out.println( d.getClass() );//返回此Object 的运行时类System.out.println( d.getDate() );//获取今天是一个月里的第几天
 ​
 System.out.println( d.getHours() );//获取现在是几点
 ​
 System.out.println( d.getDay() );//今天星期几
 ​
 System.out.println( d.getMinutes() );//获取一个小时里的第几分钟
 ​
 System.out.println( d.getMonth() + 1 );//底层获取到自然月-1,0~11表示12个月
 ​
 System.out.println( d.getSeconds() );//获取现在是哪一秒
 ​
 System.out.println( d.getYear() );//获取从1900年到现在一共是多少年
 ​
 System.out.println( d.toLocaleString());//2020-9-15 14:40:03

日期工具SimpleDateFormat

概述

把 String类型的日期 和 Date类型的日期 互转

创建对象

  SimpleDateFormat(String pattern)

常用方法

  Date -> String : String format(Date date)
 ​
  String -> Date : Date parse(String text)

BigDecimal/BigInteger

概述

BigDecimal专门用来解决 小数运算 不精确的问题

BigInteger专门用来解决 超大的 整数运算

不可变的、任意精度的有符号十进制数。

BigDecimal创建对象

BigDecimal(double val) --构造方法有坑，会使计算更加不精确。

BigDecimal(String val)

常用方法

加法运算: BigDecimal add(BigDecimal augend)

减法运算: BigDecimal subtract(BigDecimal subtrahend)

乘法运算: BigDecimal multiply(BigDecimal multiplicand)

除法运算: BigDecimal divide(BigDecimal divisor，要保留的小数位，舍入模式)四舍五入 BigDecimal.ROUND_HALF_UP

File文件工具类

概述

文件和目录路径名的抽象表示形式

创建对象

File(String pathname)

调用方法

 System.out.println( file.length() );//获取文件的大小
 ​
 
 ​
 System.out.println( file.exists() );//判断文件是否与存在
 ​
 
 ​
 System.out.println( file.isFile() );//判断资源是文件吗
 ​
 
 ​
 System.out.println( file.isDirectory() );//判断资源是文件夹吗
 ​
 
 ​
 System.out.println( file.getName() );//获取文件名
 ​
 
 ​
 System.out.println( file.getAbsolutePath() );//获取完整路径
 ​
 
 ​
 
 ​
 System.out.println( file.getParent() );//获取文件的父路径
 ​
 
 ​
 file = new File("F:java2.txt");
 ​
 System.out.println( file.createNewFile() );//创建不存在的文件2.txt
 ​
 
 ​
 file = new File("F:javaabc");
 ​
 System.out.println( file.mkdir() );//创建不存在的文件夹abc
 ​
 
 ​
 file = new File("F:javamnx");
 ​
 System.out.println( file.mkdirs() );//创建不存在的多个文件夹m n x
 ​
 
 ​
 file = new File("F:java2.txt");
 ​
 System.out.println( file.delete() );//删除文件 或者 空的文件夹
 ​
 
 ​
 file = new File("F:java");
 ​
 String[] names = file.list() ;//获取所有资源的 名字 存入String[]
 ​
 System.out.println( Arrays.toString(names) );//[1.txt, abc, m]
 ​
 
 ​
 File[] fs = file.listFiles() ;//获取所有资源 并封装成一个一个的File对象,存入File[]--推荐!!
 ​
 System.out.println( Arrays.toString(fs) );
 ​
 
 ​
 //TODO 创建3个File对象并存入容器里(数组)
 ​
 File f1 = new File("文件或者文件夹路径 1");
 ​
 File f2 = new File("文件或者文件夹路径 2");
 ​
 File f3 = new File("文件或者文件夹路径 3");
 ​
 
 ​
 File[] a = new File[3];//怎么决定数组的类型?--看你要存的数据的 类型
 ​
 •   a[0] = f1;
 ​
 •   a[1] = f2;
 ​
 •   a[2] = f3;
 ​
 •   System.out.println( Arrays.toString(a) );
 ​
 

统计文件夹里 所有文件的大小

 1,接收用户输入 文件夹路径
 ​
 String path = new Scanner(System.in).nextLine();
 ​
 File ff = new File(path);//封装成File对象
 ​
 2,列出 文件夹里 的所有资源,并封装成一个一个的File对象,放入File[]
 ​
 •   File[] aa = ff.listFiles() ;
 ​
 •   long sum = 0 ;//定义变量,记录文件的总和
 ​
 •   //循环数组,获取每个资源 aa[i]
 ​
 •   for (int i = 0; i < aa.length ; i++) {
 ​
 • //   3,判断资源 是文件夹 还是文件
 ​
 •     if( aa[i].isDirectory() ){//如果是文件夹返回true
 ​
 • System.out.println( aa[i].getName() );//4,如果是文件夹,输出文件夹名称
 ​
 •     }
 ​
 else if( aa[i].isFile() ){
 ​
 • //   5.如果是文件 求和.
 ​
 •     sum = sum + aa[i].length() ;
 ​
 •     }
 ​
 •   }
 ​
 •   System.out.println("文件的总大小是:"+sum);
 ​
 • }
 ​
 • }

可以使用父类的方法,也可以使用自己的扩展方法.而且还能new

概述

字节流通常用来对数据 进行 读写操作.

可以对电脑里的 二进制文件 进行操作.

字节流读 : 是指 从磁盘到 程序 的过程,是指程序需要读取数据

InputStream

是父类,而且被修饰成一个抽象类.不能new,我们只学习父类的共性方法

常用方法

abstract int read()

从输入流中读取数据的下一个字节。

int read(byte[] b)

从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。

int read(byte[] b, int off, int len)

将输入流中最多 len 个数据字节读入 byte 数组。

void close()

关闭此输入流并释放与该流关联的所有系统资源。

FileInputStream

可以使用父类的方法,也可以使用自己的扩展方法.而且还能new

FileInputStream 从文件系统中的某个文件中获得输入字节。

创建对象

FileInputStream(String name)

FileInputStream(File file)

BufferedInputStream 缓冲流/高级流

可以使用父类的方法,也可以使用自己的扩展方法.而且还能new

在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。

字节流写出

是指从程序到磁盘的过程

OutputStream

此抽象类是表示输出字节流的所有类的超类。

父类被修饰成了抽象类,不能new,只能学习父类提供的共性方法

方法

  void close()
 ​
 • void flush()
 ​
 • void write(byte[] b)
 ​
 • void write(byte[] b, int off, int len)
 ​
 • abstract void write(int b)

FileOutputStream

文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流

子类可以使用 父类的方法,还能使用自己的扩展方法,还能new

FileOutputStream(File file)

FileOutputStream(String name)

FileOutputStream(String name, boolean append)

FileOutputStream(File file, boolean append)

BufferedOutputStream 高级流/缓冲流

--该类实现缓冲的输出流

--创建对象

BufferedOutputStream(OutputStream out)

泛型

概述

由于集合中添加的元素类型太丰富.

如果想要限制集合中元素的类型 ,就要使用泛型.

泛型是（Generics）是JDK1.5 的一个新特性，其实就是一个『语法糖』.标志<>

好处

--通过泛型的语法定义，约束集合元素的类型，进行安全检查，把错误显示在编译期

--代码通用性更强。

可以出现的位置

--类上 : public class Student{}

--方法上: public void eat(E d){}

Collection接口

概述

Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的

常用方法

c.clear(); //清空集合

System.out.println( c.contains(13) );//判断c里包含13这个元素吗

System.out.println( c.equals(123) );//判断c是否和123相等

System.out.println( c.hashCode() );//获取c在内存中的哈希码值

System.out.println( c.isEmpty() );//判断c是否为空

System.out.println( c.remove(2) );//移除指定的数据

System.out.println( c.size() );//获取c集合的长度

// 集合转数组

Object[] os = c.toArray();//把c里的数据存入数组里

System.out.println( c.addAll(c2) );//把c2加到c里去

System.out.println( c.containsAll(c2) );//判断c里包含c2吗

//移除c中那些也包含在c2中的所有元素

// System.out.println( c.removeAll(c2) );

//仅保留c中那些也包含在c2的元素

// System.out.println( c.retainAll(c2) );

Iterator it = c.iterator();

//hasNext()-判断集合里有元素吗,有元素就获取,没有就不取.

while( it.hasNext() ){

Integer in = it.next();

//next()-把元素获取出来

System.out.println(in);

List子接口

概述

可以使用父接口Collection 的所有方法.也可以有自己的扩展方法.

接口不能被new,学习提供的共性方法

特点

--有序

--可重复

--可以存多个null

--有索引

常用方法

--继承自父接口Collection的

略...

!!!自己扩展的

void add(int index, E element) 在索引处插入新的值

boolean addAll(int index, Collection c)

E get(int index) 获取下标为index的元素

int indexOf(Object o) 获取o这个元素第一次出现的索引值

int lastIndexOf(Object o) 获取o这个元素最后一次出现的索引值

E remove(int index) 移出索引处的元素

E set(int index, E element) 在该索引处，添加元素

List subList(int fromIndex, int toIndex)截取一段集合

ArrayList

概述

是List接口的实现类 . 底层用一个 大小可变的数组 来存放数据的.

创建对象

ArrayList() ​ 构造一个初始容量为 10 的空列表。

LinkedList

概述

是List 接口的链接列表实现.

创建对象

LinkedList() ​ 构造一个空列表。

常用方法

list.addFirst("钢铁侠");//添加首元素 list.addLast("灭霸");//添加尾元素

System.out.println( list.getFirst() );//获取首元素 System.out.println( list.getLast() );//获取尾元素

System.out.println( list.removeFirst() );//移除首元素 System.out.println( list.removeLast() );//移除尾元素

Set接口

概述 一个不包含重复元素的 collection。 特点 --不能重复 --没有索引 --无序

HashSet

概述 ​ 此类实现 Set 接口,底层是一个哈希表。它不保证 set 的迭代顺序；特别是它不保 证该顺序恒久不变。此类允许使用 null 元素。 ​ 创建对象 ​ HashSet() ​ 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75

特点: 元素不能重复 + 数据无序 + 可以存一个null

Map接口

概述

map里的数据都是一个一个的 键值对 ,当向map里存储数据时,需要指定这条数据的key 和value而且,key不能重复,如果重复就会把value覆盖掉.

常用方法

public class Test1_Map { public static void main(String[] args) { //1,创建map对象 Map map = new HashMap(); //2,调用方法 //TODO map的特点: 存的数据都是 键值对形式 + 无序... map.put(9529,"石榴姐"); map.put(9529,"如花姐姐"); map.put(9528,"秋香姐"); map.put(9527,"唐伯虎");

 public static void main(String[] args) {
  //1,创建map对象
  Map map = new HashMap();
  //2,调用方法
  //TODO map的特点: 存的数据都是 键值对形式 + 无序...
  map.put(9529,"石榴姐");
  map.put(9529,"如花姐姐");
  map.put(9528,"秋香姐");
  map.put(9527,"唐伯虎");
  System.out.println(map);
  //     map.clear();//清空map集合
  System.out.println( map.containsKey(9529) );//判断map是否包含指定的key
  System.out.println( map.containsValue("唐伯虎") );//判断map是否包含指定的value
  System.out.println( map.equals(123) );//判断map和123相等吗
  System.out.println( map.get(9527) );//根据key去map里找value
  System.out.println( map.hashCode() );//获取哈希码值
  System.out.println( map.isEmpty() );//判断是否为空
  System.out.println( map.remove(9529) );//根据key删除记录,并返回value
  System.out.println( map.size() );//获取map里元素的个数

迭代map里的数据:没提供直接的迭代方法,需要,把map转成set,进而迭代set来获取数据.

  //TODO 方式1: Set keySet() -- 把map里的key存入set
  //思路:调用方法,把map转成set.
  Set set = map.keySet() ;
  // 遍历set得到每一个key.
  for(Integer key : set){
  // 拿着set遍历得到的key再回map里找value
  String value = map.get(key);
  System.out.println(key +"======"+value);
  }
  //TODO 方式2: Set> entrySet()--把map里的整条记录封装成Entry存入set
  //思路:调用方法,把map转成set.
  Set> set2 = map.entrySet() ;
  // 遍历set得到每一个Entry.
  for(Map.Entry entry : set2){
  // 再获取Entry封装着key和value.
  Integer key = entry.getKey();
  String value = entry.getValue();
  System.out.println(key +"~~~~"+ value);
  }
  //TODO 方式3: Collection values() -- 用的少!
  Collection values = map.values();
  for (String value : values) {
  System.out.println(value);
  }
 ​
 ​

HashMap实现类

概述

底层为了一个哈希表/散列表. ​ 底层在存储数据时,本质上是向桶里添加数据.默认容量是16,当达到16的0.75阈值后,再增加的数据 rehash开辟新空间

创建对象

HashMap() ​ 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。

练习

统计字符串中的字符出现次数 --需求:接收用户输入的一串字符串，统计出现的每个字符的个数 --代码 package cn.tedu.api;

  import java.util.HashMap;
  import java.util.Map;
  import java.util.Scanner;
 ​
  //测试
  //需求:接收用户输入的一串字符串，统计出现的每个字符的个数
  public class Test3_HashMap {
  public static void main(String[] args) {
  //1,接收用户输入的一串字符串 abcab
  String input = new Scanner(System.in).nextLine();
  //定义map,用来存储数据 {a=2 ,b=2 ,c=1}
  //map里的 key是出现的字符,value是这个字符出现了几次
  Map map = new HashMap();
  //2,遍历字符串,获取每个字符
  for (int i = 0; i < input.length() ; i++) {
  char key = input.charAt(i);
  //3,统计每个字符的个数--并存入map {a=2 ,b=2 ,c=1}
  Integer value = map.get(key) ;
  //value的值到底存啥? -- 如果存过就+1,如果没存过就存1
  if(value == null){
  value = 1;
  }else{
  value = value + 1;
  }
  //把准备好的key和value存入map
  map.put(key,value);
  }
  System.out.println(map);
  }
  }

Collections工具类

概述

此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。 ​ --2,常用方法 ​ static boolean addAll(Collection c, T... elements) ​ 将所有指定元素添加到指定 collection 中。 ​ static T min(Collection coll) ​ 根据元素的自然顺序 返回给定 collection 的最小元素。 ​ static T max(Collection coll) ​ 根据元素的自然顺序 返回给定 collection 的最大元素。 ​ static void reverse(List list) ​ 反转指定列表中元素的顺序。 ​ static void sort(List list) ​ 根据元素的自然顺序 对指定列表按升序进行排序。 ​ static void swap(List list, int i, int j) ​ 在指定列表的指定位置处交换元素。

测试

package cn.tedu.api;

  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
 ​
  //测试 集合工具类Collections
  public class Test4_Collections {
  public static void main(String[] args) {
  //用工具类前:向List集合里添加一些元素
  List list = new ArrayList();
  list.add(1);
  list.add(2);
  list.add(3);
  list.add(4);
  list.add(5);
  System.out.println(list);//[1, 2, 3, 4, 5]
  //用工具类后
  List list2 = new ArrayList();
  //TODO 1,addAll()--用来给指定的list2集合添加一些数据
  Collections.addAll(list2,13,65,82,26,39,61);
  //[13, 65, 82, 26, 39, 61]
  System.out.println(list2);
  //TODO 2,max()求最大值 min()求最小值
  System.out.println( Collections.max(list2) );
  System.out.println( Collections.min(list2) );
  //TODO 3,reverse()翻转数据
  Collections.reverse(list2);
  System.out.println(list2);//[61, 39, 26, 82, 65, 13]
  //TODO 4,sort()排序,默认从小到大
  Collections.sort(list2);
  System.out.println(list2);//[13, 26, 39, 61, 65, 82]
  //TODO 5,swap() 交换指定位置的两个元素
  Collections.swap(list2,1,4);
  System.out.println(list2);//[13, 65, 39, 61, 26, 82]
  }
  }

多线程

概念

--进程和线程的区别 ​ -- 进程是 正在运行的程序 ​ -- 线程是 系统可以调度的最小单位,是进程的实际运作单位 ​ 一个软件运行 需要依赖多个进程,一个进程的运行可以依赖多个线程 ​ --并行和并发的区别 ​ --并发是 多个资源 抢占 CPU,让CPU去干活 ​ --并行是 多个资源要干活,只不过有多个CPU去干活,根本没发生抢的现象 ​ 多线程是 为了提高程序的执行效率,是指相当于 把一件事分给10个人,抢着干 -- 并发

多线程编程

Thread类

--创建对象 ​ Thread() ​ 分配新的 Thread 对象。 ​ Thread(Runnable target) ​ 分配新的 Thread 对象。 ​ Thread(Runnable target, String name) ​ 分配新的 Thread 对象。 ​ Thread(String name) ​ 分配新的 Thread 对象。 ​ --常用方法 ​ static Thread currentThread() ​ 返回对当前正在执行的线程对象的引用。 ​ long getId() ​ 返回该线程的标识符。 ​ String getName() ​ 返回该线程的名称。 ​ void run() ​ 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法； ​ void setName(String name) ​ 改变线程名称，使之与参数 name 相同。 ​ static void sleep(long millis) ​ 在指定的毫秒数内让当前正在执行的线程休眠 ​ void start() ​ 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 ​ void stop() ​ 已过时。 该方法具有固有的不安全性。用 Thread.stop 来终止线程

模拟多线程编程

--继承Thread类 ​

 package cn.tedu.thread;
  //模拟多线程编程
  public class Test2_Thread {
  public static void main(String[] args) {
  //4,创建对象MyThread测试
  MyThread t = new MyThread();
  t.setName("杨幂");//修改线程名称
  //       t.run();//只是一个普通的方法调用,并不能实现多线程的抢占效果.只是顺序执行
  t.start();//TODO 6,是真正的开启线程,产生随机性的特点
 ​
 ​
 ​
 •       //TODO 5, 模拟多线程 >= 2
 •       MyThread t2 = new MyThread();
 •       t2.setName("Anglelababa");
 • //       t2.run();
 •       t2.start();
 ​
 •       /* 7, 测试得到的结果展示了多线程程序执行的随机性特点:两个线程一直在抢占CPU的执行权
 •           Thread-0====9
 •           Thread-0====10
 •           Thread-1====1
 •           Thread-0====11
 •           Thread-1====2
 •           Thread-0====12
 •           Thread-1====3
 •           Thread-0====13
 •         */
 •   }
 • }
 • //1,创建自定义的线程类 -- 继承Thread类
 • class MyThread extends Thread{
 •   //2,多线程的所有业务代码 , 放入重写的run()里 --右键..generate..override methods..ok
 •   @Override
 •   public void run() {
 • //       super.run();
 •   //TODO 3,需求:打印50次线程名称
 •       for (int i = 0; i < 50; i++) {
 •           System.out.println( super.getName() +"===="+i );
 •       }
 •   }
 • }

同步锁

-把有问题的代码加锁--同步锁 -- 同步是指没钥匙就排队等待的状态. 锁是指把操作共享资源的代码锁起来 -- 通过sychronized关键字实现

普通方法 会自动分配默认的锁对象 是this

静态方法 的锁对象会自动分配 是类名.class

如果是普通资源,锁对象任意只要是同一个锁对象就可以

如果是静态资源,锁对象 必须是 类名.class

语法

--可以用在方法上 ​ -- public synchronized void append() { ​ --可以用在代码块上 ​ -- synchronized(锁对象){//这个对象可以任意,但是,必须是同一个对象 ​ 有问题的代码 ​ }

设计模式

概述

软件设计模式（Design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过 分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解 、保证代码可靠性、程序的重用性。

单例模式(Singleton)

保证一个类仅有一个实例，并提供一个访问它的全局访问点。 模拟单例设计模式

  package cn.tedu.design;
 • //模拟-- 23种设计模式里的 单例设计模式--保证一个类仅有一个对象
 • //单例模式 :
 • //1,私有化构造方法,不能让外界随意new
 • //2,在类的内部,自己new好一个对象,让外界用
 • //3,提供一个全局的访问点get(),用来获取new好的对象
 • //好处是 : 控制外界new的权利,节省内存节省时间--SSM大量使用
 • public class Test1_Singleton {
 •   public static void main(String[] args) {
 •       Person p1 = Person.getP();//5,调用静态方法,使用对象
 •       Person p2 = Person.getP();
 •       System.out.println(p1 == p2);//true
 ​
 •       Student s1 = Student.getS();
 •       Student s2 = Student.getS();
 •       System.out.println( s1 == s2);//true
 •   }
 • }

懒汉式--面试的重点!!! -- 延迟加载 + 线程不安全

 class Student{
  //1,私有化构造
  private Student(){}
  //2,自己声明一个对象
  static private Student s ; //null
  //3,对外提供的一个get()
  synchronized static public Student getS() {
 // 4, 在多线程编程中,共享资源s,被多条语句操作,一定会有安全隐患 -- 必须加锁
 // 锁加在 同步方法或者同步代码块都可以,
 // 如果共享资源是静态资源,那么,锁对象必须 固定是 类名.class
 // 如果方法是普通方法锁对象默认是this,如果是静态方锁对象默认是类名.class
  //       synchronized (Student.class){
  if(s == null){
 //如果是默认值null,就创建对象--保证了单例!!
  s = new Student();
  }
  return s;
  //       }
  }
  }

饿汉式--学习工作中使用的方式!!!

 class Person{
  //1, 私有化构造方法 -- 不让外界随便new
  private Person(){}
 ​
 • //2,在 类的内部 提供一个new好的对象
 • //加static -- 因为静态只能调用静态,所以,想要被静态的getP()调用,必须修饰成静态的
 •   static private Person p = new Person();
 ​
 •   //3,提供公共的访问方式getXxx(),获取p对象
 • //加static -- 目前无法通过创建对象来调用getP(),所以变成静态的,直接通过类名来调用getP()
 •   static public Person getP(){
 •       return p ;//把创建好的对象p,返回给调用位置
 •   }
 • }

反射

概述

Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身 进行检查，或者说“自审”，也有称作“自省”。反射非常强大，它甚至能直接操作程序的私有属性。 我们前面学习都有一个概念，private的只能类内部访问，外部是不行的，但这个规定被反射 赤裸裸的打破了。

反射就像一面镜子，它可以在运行时获取一个类的所有信息，可以获取到任何定义的信息（包 括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。 --本质 ​ JVM利用反射技术,来解析.class文件里的所有数据,包括 公开的和私有的 成员变量/成员方 法/构造方法/..... 并把所有获取到的资源,封装起来形成Class工具类. ​ 然后通过Class工具类提供了各种方法来解析获取各种... --开发思路 ​ --获取Class对象 ​ --通过Class工具类提供的各种方法来后去所有资源 --获取Class对象的方式 ​ --Class.forName(“类的全路径”); ​ --类名.class ​ --对象.getClass();

创建Demo类

package cn.tedu.reflect;

  import org.junit.Test;
 ​
  //测试 反射
  public class Demo {
  public Demo(){}
  public Demo(String name) {
  this.name = name;
  }
  public Demo(String name, int age) {
  this.name = name;
  this.age = age;
  }
  public String name;
  public int age;
 ​
  @Test
  public void show(){
  System.out.println("show");
  }
  public void save(int id){
  System.out.println("保存成功!");
  }
  }

创建测试类

 package cn.tedu.reflect;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Field;
  import java.lang.reflect.Method;
  import java.util.Arrays;
  //反射 Demo类里的资源
  //总结
  //原理是 :
  //1,通过 类的加载器 把java里的类,加载进内存. 然后通过编译器,把.java文件编译变成.class文件
  //2,JVM拿到你的.class文件,开始解析里面的所有资源 . 把.class文件封装成Class对象
  //3,通过Class工具类提供的各种getXxx() 获取各种资源
 ​
 • //用过Class工具类的方法:
 • //1,getConstructors() -- 获取所有的   公开的 构造方法们~~~
 • //2,getFields() -- 获取所有的 公开的 成员变量们~~~
 • //3,getMethods() -- 获取所有的 公开的 成员方法们~~~
 ​
 • public class Test1_Reflect {
 •   public static void main(String[] args) throws Exception {
 • //       method();//反射.class里的构造方法
 • //       method2();//反射.class里的 普通方法
 • //       method3();//反射.class里的 成员变量
 •       method4();//利用反射创建对象
 •   }
 •   //利用反射创建对象
 •   public static void method4() throws Exception {
 •       //1,反射Class对象
 •       Class a = Demo.class;
 •       //2,创建对象
 •       //newInstance()默认返回的是Object父类类型
 •       Object d = a.newInstance();//默认会触发无参构造
 • //     Demo d = (Demo)a.newInstance();为了用子类的特有功能
 •       //cn.tedu.reflect.Demo@677327b6
 •       System.out.println( d );
 •   }
 •   //反射.class里的 成员变量
 •   public static void method3() {
 •       //1,获取Class对象
 •       Class a = Demo.class;
 •       //2,获取 所有 公共的 成员变量们~
 •       Field[] fs = a.getFields();
 •       //3,获取每个 成员变量f
 •       for (Field f : fs) {
 •           //4,获取 变量名
 •           System.out.println( f.getName() );
 •           //5,获取 变量类型
 •           System.out.println( f.getType().getName() );
 •       }
 •   }
 •   //反射.class里的 普通方法
 •   public static void method2() {
 •       //1,获取Class对象
 •       Class a = Demo.class;
 •       //2,反射所有 公开的 方法们~~~
 •       //自己的和父类的
 •       Method[] ms = a.getMethods();
 •       //3,获取 每个方法m
 •       for (Method m : ms) {
 •           //4,获取 方法名
 •           System.out.println( m.getName() );
 ​
 •           //5,获取 方法的参数类型
 •           Class[] css = m.getParameterTypes();
 •           System.out.println( Arrays.toString(css) );
 •       }
 •   }
 •   //TODO 反射.class文件里的 构造方法
 •   public static void method() {
 •       //1,反射class对象
 •       Class a = Demo.class ;
 •       //2,获取所有 构造方法们 ~
 •       Constructor[] cs = a.getConstructors();
 •       //3,获取每个构造方法x
 •       for(Constructor x : cs){
 •           //4,获取x的 参数类型们 ~
 •           Class[] css = x.getParameterTypes();
 •           System.out.println(Arrays.toString(css) );
 •       }
 •   }
 • }

暴力反射

概述

把.class文件里的 所有数据获取到. 包括public的 和private的 新的API ​ getDeclaredFields() -- 获取 所有 成员变量 ​ getDeclaredField() -- 获取 指定的 成员变量 ​ getDeclaredMethods() -- 获取 所有 成员方法 ​ getDeclaredMethod() -- 获取 指定的 成员方法 ​ getDeclaredConstructors() -- 获取 所有 构造方法 ​ getDeclaredConstructor() -- 获取 指定的 构造方法

创建Student类

 package cn.tedu.reflect;
  import org.junit.Test;
  //测试 暴力反射
  public class Student {
  public String name;
  private int age ;
 ​
 •         public void show(){
 •       System.out.println("show()");
 •   }
 ​
 •   public void save(int a){
 •       System.out.println("保存成功!");
 •   }
 •   private void get(String a){
 •       System.out.println("保存成功!"+a);
 •   }
 •   private void delete(int id){
 •       System.out.println("删除成功!"+id);
 •   }
 }

创建测试类

  package cn.tedu.reflect;
 • import org.junit.Test;
 • import java.lang.reflect.Field;
 • import java.lang.reflect.Method;
 • import java.util.Arrays;
 • //测试 暴力反射
 • //总结:
 • //1, 暴力反射 可以获取.class文件里的public和private资源
 •
 • public class Test2_Baoli {
 •   public static void main(String[] args) throws Exception {
 • //       method();//暴力反射 所有成员方法
 • //       method2();//暴力放射 指定方法并执行
 • //       method3();//练习
 • //       method4();//暴力反射 所有成员变量
 • //       method5();//暴力反射 指定成员变量
 •       method6();//执行 注解方法
 •   }
 •
 ​

 private static void method6() throws Exception {
 •       //1,获取Class对象
 •       Class a = Student.class;
 •       Object o = a.newInstance();
 •       //2,获取所有方法
 •       Method[] ms = a.getDeclaredMethods();
 •       //3,遍历得到每个方法m
 •       for (Method m : ms) {
 •           //4,获取 指定的 Test 注解--参数就是注解的Class
 •           Test test = m.getDeclaredAnnotation(Test.class);
 •           //5,判断哪些有 就invoke()执行
 •           if(test != null){
 •               //invoke(m,n)-m是对象名-n是要给方法传递的参数
 •               m.invoke(o,null);
 •           }
 •       }
 •   }

  //TODO 暴力反射 指定成员变量
 •   private static void method5() throws Exception {
 •       Class a = Student.class;
 •       //1,根据变量名获取 指定的变量f
 •       Field f = a.getDeclaredField("age");
 •       f.setAccessible(true);//设置私有的访问权限!!!
 ​
 •       //2,set()设置值
 • //第一个参数是 指定的对象名 第二个参数是 要给属性设置的值
 •       Object o = a.newInstance();
 •       f.set(o,100);
 •       //3,get()获取值 -- 需要指定要获取哪个对象的
 •       System.out.println( f.get(o) );
 •   }

 //暴力反射 所有成员变量
 •   private static void method4() {
 •       //1,获取Class对象
 •       Class a = Student.class;
 •       //2,获取 所有 成员变量们~
 •       Field[] fs = a.getDeclaredFields();
 •       //3,获取每个 成员变量f
 •       for (Field f : fs) {
 •           //4,获取 变量名
 •           System.out.println( f.getName() );
 •           //5,获取 变量类型
 •           System.out.println( f.getType().getName() );
 •       }
 ​
 •   }

  public static void method3() throws Exception {
 •       Class a = Student.class;
 • Method m = a.getDeclaredMethod("delete", int.class);
 •       m.setAccessible(true);//设置私有的访问权限
 ​
 •       Object o = a.newInstance();
 •       m.invoke(o,10);//执行指定方法
 •   }
 •

 //暴力放射 指定方法并执行
 •   public static void method2() throws Exception {
 •       //1,获取Class对象
 •       Class a = Student.class;
 •       //2,获取指定的某个方法
 •       //第一个参数是 指定的方法名称
 •       //第二个参数是 该方法需要的参数类型的Class对象
 •       Method m = a.getDeclaredMethod("get",String.class) ;
 ​
 •       m.setAccessible(true);//开启访问权限!!!!!!!
 •       //3,让方法执行起来invoke
 •       //第一个参数是 指定对象
 •       //第二个参数是 指定给该方法传入的参数
 •       Object o = a.newInstance();
 •       m.invoke(o,"hello");
 •   }

 //TODO 暴力反射成员方法 getDeclaredMethods()
 •   public static void method() {
 •       //1,获取Class对象
 •       Class a = Student.class;
 •       //2,反射所有 方法们~~~
 •       Method[] ms = a.getDeclaredMethods();
 •       //3,获取 每个方法m
 •       for (Method m : ms) {
 •           //4,获取 方法名
 •           System.out.println( m.getName() );
 ​
 •           //5,获取 方法的参数类型
 •           Class[] css = m.getParameterTypes();
 •           System.out.println( Arrays.toString(css) );
 •       }
 •   }
 • }
 ​
 ​

反射的练习

创建Person类

  //练习反射
  public class Person {
  String name;
  private int age ;
  public void save(int id){
  System.out.println("save.."+id);
  }
  private void delete(int id){
  System.out.println("delete.."+id);
  }
  }

创建测试类

  import java.lang.reflect.Field;
  import java.lang.reflect.Method;
 ​
  //练习反射
  public class Test3_Person {
  public static void main(String[] args) throws Exception {
  //获取Class对象
  Class a = Person.class ;
  //       method(a);//反射属性并set()/get()
  method2(a);//反射方法并运行
  }
  //反射方法并运行
  private static void method2(Class m) throws Exception {
  //反射 指定的 私有方法
  Method me = m.getDeclaredMethod("delete",int.class);
  //设置访问权限 !!!!
  me.setAccessible(true);
  //执行方法
  Object o = m.newInstance();
  me.invoke(o,200);
  }
  //反射属性并set()/get()
  private static void method(Class m) throws Exception {
  //属性被封装无法直接用,可以通过反射操作 ~~~
  //       new Person().age = 20 ;
  //反射 指定名称的 属性
  Field f = m.getDeclaredField("age");
  //设置私有的访问权限 !!!!
  f.setAccessible(true);
  //利用反射创建对象
  Object o = m.newInstance();
  //给属性设置具体值
  f.set(o,66);
  //获取属性值
  System.out.println( f.get(o) );
  }
  }

内部类

概述

内部类 是为了 给外部类服务的. 结构 ​ class A{//外部类 ​

class B{//内部类 -- 看做是A类的一个特殊的成员 ​ ​ } ​ } 特点 ​ --内部类 随着位置的不同,名字和作用都不同 ​ --在成员位置(类里方法外)的内部类,叫成员内部类 ​ --在局部位置(方法里)的内部类,叫局部内部类 ​ --在内部类 使用 外部类的资源 --直接使用 ​ --在外部类 使用 内部类的资源 -- 创建内部类对象访问 !!

入门案例

 package cn.tedu.inner;
  //测试 内部类
  public class Test3_Inner {
  public static void main(String[] args) {
  //1,想用内部类的资源--创建内部类的对象
  //外部类名.内部类名 变量名 = 外部类对象.内部类对象
  Outer.Inner oi = new Outer().new Inner();
  System.out.println( oi.age );
  oi.in();
  }
  }

 class Outer{//外部类
  String name ;
  public void out(){
  //TODO 3, 在外部类 使用 内部类的资源 -- 创建内部类对象访问 !!
  System.out.println( new Inner().age );
  System.out.println("out..");
  }
  class Inner{ //内部类--在成员位置的内部类是成员内部类
  int age;
  public void in(){
  //TODO 2, 在内部类 使用 外部类的资源 --直接使用
  out();
  System.out.println("in..");
  }
  }
  }

匿名内部类

  public class Test4_Inner {
  public static void main(String[] args) {
 
  new Inter(){//相当于创建了接口的对象
  @Override//重写了接口里的方法
  public void save() {
  System.out.println("save()");
  }
  }.save();//调用了指定的方法
  //TODO
  new Inter2(){
  @Override
  public void update(int id) {
  System.out.println("更新数据成功,id是:"+id);
  }
  }.update(10);
  //TODO
  Inter3 in = new Inter3(){
  @Override
  public void update(int id) {
  System.out.println("更新成功,id是:"+id);
  }
  @Override
  public void delete(int id) {
  System.out.println("删除成功,id是:"+id);
  }
  }；
  in.delete(10); //匿名对象干一个活儿,那就给对象起个名字干好多活儿
  in.update(5);

  interface Inter{
  //可以简写,会自动拼接public abstract
  void save();
  }
 ​
 interface Inter2{
  void update(int id);
  }
 ​
 interface Inter3{
  void update(int id);
  void delete(int id);
  }

你可能感兴趣的:(java)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • 【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java开发语言
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式java
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
  • 安装数据库首次应用 Array_06 javaoraclesql
    可是为什么再一次失败之后就变成直接跳过那个要求 enter full pathname of java.exe的界面 这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！ 注意第一次，使用SQL D
  • Weblogic Server Console密码修改和遗忘解决方法 bijian1013 Welogic
            在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。 一.修改Console密码         打开weblogic控制台，安全领域 --> myrealm -->&n
  • IllegalStateException: Cannot forward a response that is already committed Cwind javaServlets
    对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。 示例代码： protected void doPost() { if (someCondition) { sendRedirect(); } forward(); // Thi
  • 基于流的装饰设计模式 木zi_鸣 设计模式
    当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。 自定义的类成为装饰类 模仿BufferedReader，对Reader进行包装，体现装饰设计模式 装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。 装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系 装饰类因为增强已有对象，具备的功能该
  • Linux中的uniq命令 被触发 linux
    Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情 况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如 果输入文件用“- ”表示，则从标准输入读取。 AD： uniq [选项] 文件 说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
  • 正则表达式Pattern 肆无忌惮_ Pattern
    正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。   例如，我们需要对QQ号码格式进行检验 规则是长度6~12位  不能0开头  只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} &nbs
  • Oracle高级查询之OVER (PARTITION BY ..) 知了ing oraclesql
    一、rank()/dense_rank() over(partition by ...order by ...) 现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： select e.ename, e.job, e.sal, e.deptno from scott.emp e, (se
  • Python调试 矮蛋蛋 pythonpdb
    原文地址： http://blog.csdn.net/xuyuefei1988/article/details/19399137 1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： http://www.ibm.com/d
  • webservice传递自定义对象时函数为空，以及boolean不对应的问题 alleni123 webservice
    今天在客户端调用方法 NodeStatus status=iservice.getNodeStatus(). 结果NodeStatus的属性都是null。 进行debug之后，发现服务器端返回的确实是有值的对象。 后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。 本来是因为逻辑上不需要在客户端使用setter， 结果改了之后竟然不能获取带属性值的
  • java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针 百合不是茶
    C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作：   定义一个指针p来指向a的地址（&是地址符号）：        
  • Eclipse打不开，提示“An error has occurred.See the log file ***/.log” bijian1013 eclipse
    打开eclipse工作目录的\.metadata\.log文件，发现如下错误： !ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 !MESSAGE Application error !STACK 1 java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
  • spring aop实例annotation方法实现 bijian1013 javaspringAOPannotation
            在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut AdviceMethods.jav
  • [Velocity一]Velocity语法基础入门 bit1129 velocity
    用户和开发人员参考文档 http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html   注释 1.行级注释## 2.多行注释#*  *#   变量定义 使用$开头的字符串是变量定义，例如$var1, $var2,   赋值 使用#set为变量赋值，例
  • 【Kafka十一】关于Kafka的副本管理 bit1129 kafka
    1. 关于request.required.acks   request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 0表示即不进行确认即返回。 1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 -1表示根据指定的最少Partition确认后才返回，这个在   Th
  • lua统计nginx内部变量数据 ronin47 lua nginx　 统计
    server { listen 80; server_name photo.domain.com; location /{set $str $uri; content_by_lua ' local url = ngx.var.uri local res = ngx.location.capture(
  • java-11.二叉树中节点的最大距离 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class MaxLenInBinTree { /* a. 1 / \ 2 3 / \ / \ 4 5 6 7 max=4 pass "root"
  • Netty源码学习-ReadTimeoutHandler bylijinnan javanetty
    ReadTimeoutHandler的实现思路： 开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 private final ChannelHandler timeoutHandler = new ReadTim
  • jquery验证上传文件样式及大小(好用) cngolon 文件上传jquery验证
    <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <script src="jquery1.8/jquery-1.8.0.
  • 浏览器兼容【转】 cuishikuan css浏览器IE
    浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同 问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。 碰到频率:100% 解决方案：CSS里    *{margin:0;padding:0;} 备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
  • Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数 daizj shell$#$?特殊变量
    前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码： $echo $$ 运行结果 29949   特殊变量列表 变量 含义 $0 当前脚本的文件名 $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
  • 程序设计KISS 原则-------KEEP IT SIMPLE, STUPID! dcj3sjt126com unix
    翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真 正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
  • android Activity间List传值 dcj3sjt126com Activity
    第一个Activity： import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
  • tomcat 设置java虚拟机内存 eksliang tomcat 内存设置
    转载请出自出处：http://eksliang.iteye.com/blog/2117772 http://eksliang.iteye.com/ 常见的内存溢出有以下两种: java.lang.OutOfMemoryError: PermGen space java.lang.OutOfMemoryError: Java heap space   ------------
  • Android 数据库事务处理 gqdy365 android
    使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
  • Java 打开浏览器 hw1287789687 打开网址open浏览器open browser打开url打开浏览器
    使用java 语言如何打开浏览器呢? 我们先研究下在cmd窗口中,如何打开网址 使用IE 打开 D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 使用火狐打开 D:\software\bin>cmd /c start firefox http://hw1287789
  • ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件 justjavac chromeGooglegoogle apichrome插件
    Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。 同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
  • 进程VS.线程 m635674608 线程
    资料来源： http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点 优点： 多进程模式最大
  • Linux下安装MemCached 字符串 memcached
    前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
  • java设计模式之--jdk动态代理（实现aop编程） Supanccy2013 javaDAO设计模式AOP
        与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 &
  • Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持 wiselyman spring 4
    2.1 默认方法(default method) java8引入了一个default medthod; 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展 使用default关键字 Spring 4.2支持加载在默认方法里声明的bean 2.2 将要被声明成bean的类 public class DemoService {
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他