1.Supplier 利用方法构造迭代对象

  1. import java.util.function.Supplier;
  3. public class supplier {
  4.     public static void main(String[] args) {
  5.         Supplier<String> vSupplier = new Supplier<String>() {
  6.             private int id = 0;
  8.             public String get() {
  9.                 int var = this.id++;
  10.                 return "v" + var;
  11.             }
  12.         };
  14.         for (int i = 0; i < 10; i++) {
  15.             String a = vSupplier.get();
  16.             System.out.println(a);
  17.         }
  19.     }
  20. }

2.对象序列化与反序列化

1、变量被transient修饰，变量将不会被序列化
2、transient关键字只能修饰变量，而不能修饰方法和类。
3、被static关键字修饰的变量不参与序列化，一个静态static变量不管是否被transient修饰，均不能被序列化。
4、final变量值参与序列化，final transient同时修饰变量，final不会影响transient，一样不会参与序列化

  1. import java.io.Serializable;
  2. /*
  3.     序列化和反序列化的时候,会抛出NotSerializableException没有序列化异常
  4.     类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
  5.     Serializable接口也叫标记型接口
  6.         要进行序列化和反序列化的类必须实现Serializable接口,就会给类添加一个标记
  8.         被static修饰的成员变量不能被序列化的,序列化的都是对象
  9.         静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
  10. */
  11. public class Person implements Serializable{
  12.     private static final long serialVersionUID = 1L;
  13.     private String name;
  14.     //private static int age;
  15.     //private transient int age;
  16.     public int age;
  18.     public Person(String name, int age) {
  19.         this.name = name;
  20.         this.age = age;
  21.     }
  23.     @Override
  24.     public String toString() {
  25.         return "Person{" +
  26.                 "name='" + name + '\'' +
  27.                 ", age=" + age +
  28.                 '}';
  29.     }
  31.     public String getName() {
  32.         return name;
  33.     }
  35.     public int getAge() {
  36.         return age;
  37.     }
  38. }
  1. import java.io.*;
  2. import java.util.ArrayList;
  3. /*
  4.     练习：序列化集合
  5.         对集合进序列化和反序列化
  6.     分析:
  7.         1.定义一个存储Person对象的ArrayList集合
  8.         2.往ArrayList集合中存储Person对象
  9.         3.创建一个序列化流ObjectOutputStream对象
  10.         4.使用ObjectOutputStream对象中的方法writeObject,对集合进行序列化
  11.         5.创建一个反序列化ObjectInputStream对象
  12.         6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合
  13.         7.把Object类型的集合转换为ArrayList类型
  14.         8.遍历ArrayList集合
  15.         9.释放资源
  16.  */
  17. public class Demo03Test {
  18.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  19.         //1.定义一个存储Person对象的ArrayList集合
  20.         ArrayList<Person> list = new ArrayList<>();
  21.         //2.往ArrayList集合中存储Person对象
  22.         list.add(new Person("张三",18));
  23.         list.add(new Person("李四",19));
  24.         list.add(new Person("王五",20));
  25.         //3.创建一个序列化流ObjectOutputStream对象
  26.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("10_IO\\list.txt"));
  27.         //4.使用ObjectOutputStream对象中的方法writeObject,对集合进行序列化
  28.         oos.writeObject(list);
  29.         //5.创建一个反序列化ObjectInputStream对象
  30.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("10_IO\\list.txt"));
  31.         //6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合
  32.         Object o = ois.readObject();
  33.         //7.把Object类型的集合转换为ArrayList类型
  34.         ArrayList<Person> list2 = (ArrayList<Person>)o;
  35.         //8.遍历ArrayList集合
  36.         for (Person p : list2) {
  37.             System.out.println(p);
  38.         }
  39.         //9.释放资源
  40.         ois.close();
  41.         oos.close();
  42.     }
  43. }

2.序列化实现深克隆

  1. public class Outer implements Serializable{
  2.   private static final long serialVersionUID = 369285298572941L;  //最好是显式声明ID
  3.   public Inner inner;
  4. 　//Discription:[深度复制方法,需要对象及对象所有的对象属性都实现序列化]
  5.   public Outer myclone() {
  6.       Outer outer = null;
  7.       try { // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
  8.           ByteArrayOutputStream baos = new ByteArrayOutputStream();
  9.           ObjectOutputStream oos = new ObjectOutputStream(baos);
  10.           oos.writeObject(this);
  11. 　　　　　　// 将流序列化成对象
  12.           ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
  13.           ObjectInputStream ois = new ObjectInputStream(bais);
  14.           outer = (Outer) ois.readObject();
  15.       } catch (IOException e) {
  16.           e.printStackTrace();
  17.       } catch (ClassNotFoundException e) {
  18.           e.printStackTrace();
  19.       }
  20.       return outer;
  21.   }
  22. }
  1. public class Inner implements Serializable{
  2.   private static final long serialVersionUID = 872390113109L; //最好是显式声明ID
  3.   public String name = "";
  5.   public Inner(String name) {
  6.       this.name = name;
  7.   }
  9.   @Override
  10.   public String toString() {
  11.       return "Inner的name值为：" + name;
  12.   }
  13. }

2.使用JSON实现序列化

原文链接：https://blog.csdn.net/MGL_1/article/details/89379936

jackson学习之一：基本信息

  1. 常用注解
    @JsonIgnore 注解用在属性上，当JSON序列化和反序列化时忽略该属性。
    @JsonFormat 注解用在属性上，作用是把Date类型直接转化为想要的格式， 

    1.  如：[@JsonFormat(pattern ](/JsonFormat(pattern ) = “yyyy-MM-dd HH:mm:ss”)。

@JsonAlias(“name”) 注解用在属性上，只在反序列化时生效。
@JsonProperty 注解用在属性上，作用是把该属性的名称序列化为另外一个名称，如把fullName属性序列化为name，@JsonProperty(“name”)。当序列化和反序列化名称不相同时，可以在对应的get方法上加@JsonProperty(“fullName”)和set方法上加@JsonAlias(“NaMe”)注解。set方法在反序列化时被调用，get方法在序列化时被调用。
@JsonIgnoreProperties(ignoreUnknown = true) 该注解用在类上，代表进行反序列化时如果类中没有对应的属性，可以忽略，也可以写成@JsonIgnoreProperties({ “createTime”, “updateTime” }) 指定的字段不序列化和反序列化。

  1. 序列化和反序列化
    2.1. 常用方法
  1. //序列化常用方法
  2. writeValue(File arg0, Object arg1)  把arg1转成json序列，并保存到arg0文件中。
  3. writeValue(OutputStream arg0, Object arg1) 把arg1转成json序列，并保存到arg0输出流中。
  4. writeValueAsBytes(Object arg0) 把arg0转成json序列，并把结果输出成字节数组。
  5. writeValueAsString(Object arg0) 把arg0转成json序列，并把结果输出成字符串。
  1. // 2.1.2 反序列化常用方法
  2. readValue(URL src, Class<T> valueType) 从给定资源反序列化为给定Java对象。
  3. readValue(String content, Class<T> valueType)  从给定的JSON内容字符串反序列化Java对象。
  4. readValue(File src, Class<T> valueType)  从给定的文件反序列化为Java对象。
  5. readValue(InputStream src, Class<T> valueType)  从给定的字节输入流反序列化为Java对象。
  6. readValue(Reader src, Class<T> valueType)  从给定的字符流反序列化为Java对象。

2.2 实例

  1.   // 基本对象
  2.   @Data
  3.   @JsonIgnoreProperties(ignoreUnknown = true)
  4. public static class User {
  5.     @JsonProperty(value = "NaMe")
  6.     private String name;
  7.     private int age;
  8.     @JsonAlias("home-address")
  9.     private String address;
  10.     @JsonIgnore
  11.     private Date createTime;
  12. }
  14. public static void main(String[] args) throws IOException {
  15.     // 原始字符串
  16.     String a = "{\"NaMe\":\"hello\", \"age\":2, \"home-address\":\"chengdu\"}";
  17.     ObjectMapper objectMapper = new ObjectMapper();
  18.     // 反序列化（JSON字符串转对象）
  19.     User label = objectMapper.readValue(a, User.class);
  20.     // 以下结果输出：User(name=hello, age=2, address=chengdu, createTime=null)
  21.     System.out.println(label);
  22.     // 对象序列化（对象转为JSON字符串）
  23.     final String string = objectMapper.writeValueAsString(label);
  24.     // 以下结果输出：{"age":2,"address":"chengdu","NaMe":"hello"}
  25.     System.out.println(string);
  26. }

3.归并排序

  1. public class mergeSort {
  2.     public static void merge(int[] a, int low, int mid, int high) {
  3.         int[] temp = new int[high-low+1];
  4.         int i= low;
  5.         int j = mid+1;
  6.         int k=0;
  7.         // 把较小的数先移到新数组中
  8.         while(i<=mid && j<=high){
  9.             if(a[i]<a[j]){
  10.                 temp[k++] = a[i++];
  11.             }else{
  12.                 temp[k++] = a[j++];
  13.             }
  14.         }
  15.         // 把左边剩余的数移入数组
  16.         while(i<=mid){
  17.             temp[k++] = a[i++];
  18.         }
  19.         // 把右边边剩余的数移入数组
  20.         while(j<=high){
  21.             temp[k++] = a[j++];
  22.         }
  23.         // 把新数组中的数覆盖nums数组
  24.         for(int x=0;x<temp.length;x++){
  25.             a[x+low] = temp[x];
  26.         }
  27.     }
  29.     public static int[] mergesort(int[] a, int low, int high){
  30.         int mid = (low+high)/2;
  31.         if(low<high){
  32.             mergesort(a,low,mid);
  33.             mergesort(a,mid+1,high);
  34.             //左右归并
  35.             merge(a,low,mid,high);
  36.         }
  37.         return a;
  38.     }
  40.     public static void main(String[] args) {
  41.         int[] a = new int[]{1,56,84,1,2,64,96,1,6,1,61,31,6,48,415};
  42.         mergesort(a,0,a.length);
  43.         for (int i = 0; i < a.length; i++) {
  44.             System.out.println(a[i]);
  45.         }
  46.     }
  47. }

4.遍历Map

遍历Map时，不可假设输出的key是有序的！

对Map来说，要遍历key可以使用for each循环遍历Map实例的keySet()方法返回的Set集合，它包含不重复的key的集合：

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         Map<String, Integer> map = new HashMap<>();
  4.         map.put("apple", 123);
  5.         map.put("pear", 456);
  6.         map.put("banana", 789);
  7.         for (String key : map.keySet()) {
  8.             Integer value = map.get(key);
  9.             System.out.println(key + " = " + value);
  10.         }
  11.     }
  12. }

同时遍历key和value可以使用for each循环遍历Map对象的entrySet()集合，它包含每一个key-value映射：

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         Map<String, Integer> map = new HashMap<>();
  4.         map.put("apple", 123);
  5.         map.put("pear", 456);
  6.         map.put("banana", 789);
  7.         for (Map.Entry<String, Integer> entry : map.entrySet()) {
  8.             String key = entry.getKey();
  9.             Integer value = entry.getValue();
  10.             System.out.println(key + " = " + value);
  11.         }
  12.     }
  13. }

4.computeIfAbsent

computeIfAbsent() 方法对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hashMap 中。
computeIfAbsent() 方法的语法为：
hashmap.computeIfAbsent(K key, Function remappingFunction)
注：hashmap 是 HashMap 类的一个对象。
返回值
如果 key 对应的 value 不存在，则使用获取 remappingFunction 重新计算后的值，并保存为该 key 的 value，否则返回 value。

  1. import java.util.HashMap;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         HashMap<String, Integer> prices = new HashMap<>();
  7.         prices.put("Shoes", 200);
  8.         prices.put("Bag", 300);
  9.         System.out.println("HashMap: " + prices);
  11.         // 计算 Shirt 的值
  12.         int shirtPrice = prices.computeIfAbsent("Shirt", key -> 280);
  13.         System.out.println("Price of Shirt: " + shirtPrice);
  14.         // 添加280
  16.         int shirtPrice = prices.computeIfAbsent("Shoes", key -> 280);
  17.         System.out.println("Updated HashMap: " + prices);
  18.         // 还是200
  19.     }
  20. }

4.合并Map

  1.     public static void main(String[] args) {
  2.         Map<String, String> map1 = new HashMap<String, String>();
  3.         map1.put("one", "一");
  4.         map1.put("two", "二");
  5.         map1.put("three", "三");
  7.         Map<String, String> map2 = new HashMap<String, String>();
  8.         map1.put("ten", "十");
  9.         map1.put("nine", "九");
  10.         map1.put("eight", "八");
  12.         // 合并
  13.         Map<String, String> combineResultMap = new HashMap<String, String>();
  14.         if(map1!=null&&map2!=null){
  15.             combineResultMap.putAll(map1);
  16.             combineResultMap.putAll(map2);
  17.         }
  19.         // 合并后打印出所有内容
  20.         for (Map.Entry<String, String> entry : combineResultMap.entrySet()) {
  21.             System.out.println(entry.getKey() + ":" + entry.getValue());
  22.         }
  23.     }

4.SortedMap TreeMap

SortedMap 是接口。
TreeMap 是类。
TreeMap类 实现了 SortedMap接口。

5.网络编程（BS）

参考访问地址 http://127.0.0.1:8080/11_Net/web/index.html

  1. package com.itheima.demo04.BSTCP;
  3. import java.io.*;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  7. /*
  8.     创建BS版本TCP服务器
  9.  */
  10. public class TCPServerThread {
  11.     public static void main(String[] args) throws IOException {
  12.         //创建一个服务器ServerSocket,和系统要指定的端口号
  13.         ServerSocket server = new ServerSocket(8080);
  15.         /*
  16.             浏览器解析服务器回写的html页面,页面中如果有图片,那么浏览器就会单独的开启一个线程,读取服务器的图片
  17.             我们就的让服务器一直处于监听状态,客户端请求一次,服务器就回写一次
  18.          */
  19.         while(true){
  20.             //使用accept方法获取到请求的客户端对象(浏览器)
  21.             Socket socket = server.accept();
  23.             new Thread(new Runnable() {
  24.                 @Override
  25.                 public void run() {
  26.                     try {
  27.                         //使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
  28.                         InputStream is = socket.getInputStream();
  29.                         //使用网络字节输入流InputStream对象中的方法read读取客户端的请求信息
  30.                         /*byte[] bytes = new byte[1024];
  31.                         int len = 0;
  32.                         while((len = is.read(bytes))!=-1){
  33.                             System.out.println(new String(bytes,0,len));
  34.                         }*/
  36.                         //把is网络字节输入流对象,转换为字符缓冲输入流
  37.                         BufferedReader br = new BufferedReader(new InputStreamReader(is));
  38.                         //把客户端请求信息的第一行读取出来 GET /11_Net/web/index.html HTTP/1.1
  39.                         String line = br.readLine();
  40.                         System.out.println(line);
  41.                         //把读取的信息进行切割,只要中间部分 /11_Net/web/index.html
  42.                         String[] arr = line.split(" ");
  43.                         //把路径前边的/去掉,进行截取 11_Net/web/index.html
  44.                         String htmlpath = arr[1].substring(1);
  46.                         //创建一个本地字节输入流,构造方法中绑定要读取的html路径
  47.                         FileInputStream fis = new FileInputStream(htmlpath);
  48.                         //使用Socket中的方法getOutputStream获取网络字节输出流OutputStream对象
  49.                         OutputStream os = socket.getOutputStream();
  51.                         // 写入HTTP协议响应头,固定写法
  52.                         os.write("HTTP/1.1 200 OK\r\n".getBytes());
  53.                         os.write("Content-Type:text/html\r\n".getBytes());
  54.                         // 必须要写入空行,否则浏览器不解析
  55.                         os.write("\r\n".getBytes());
  57.                         //一读一写复制文件,把服务读取的html文件回写到客户端
  58.                         int len = 0;
  59.                         byte[] bytes = new byte[1024];
  60.                         while((len = fis.read(bytes))!=-1){
  61.                             os.write(bytes,0,len);
  62.                         }
  64.                         //释放资源
  65.                         fis.close();
  66.                         socket.close();
  67.                     }catch (IOException e){
  68.                         e.printStackTrace();
  69.                     }
  70.                 }
  71.             }).start();
  72.         }
  73.         //server.close();
  74.     }
  75. }

6.网络编程(TCP/IP)TCPServer

  1. import java.io.File;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  7. import java.util.Random;
  9. public class TCPServer {
  10.     public static void main(String[] args) throws IOException {
  11.         //1.创建一个服务器ServerSocket对象,和系统要指定的端口号
  12.         ServerSocket server = new ServerSocket(8888);
  13.         //2.使用ServerSocket对象中的方法accept,获取到请求的客户端Socket对象
  15.         while(true){
  16.             Socket socket = server.accept();
  17.             /*
  18.                 使用多线程技术,提高程序的效率
  19.                 有一个客户端上传文件,就开启一个线程,完成文件的上传
  20.              */
  21.             new Thread(new Runnable() {
  22.                 //完成文件的上传
  23.                 @Override
  24.                 public void run() {
  25.                     try {
  26.                         //3.使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
  27.                         InputStream is = socket.getInputStream();
  28.                         //4.判断d:\\upload文件夹是否存在,不存在则创建
  29.                         File file =  new File("d:\\upload");
  30.                         if(!file.exists()){
  31.                             file.mkdirs();
  32.                         }
  33.                     /*
  34.                         自定义一个文件的命名规则:防止同名的文件被覆盖
  35.                         规则:域名+毫秒值+随机数
  36.                      */
  37.                         String fileName = "itcast"+System.currentTimeMillis()+new Random().nextInt(999999)+".jpg";
  38.                         //5.创建一个本地字节输出流FileOutputStream对象,构造方法中绑定要输出的目的地
  39.                         //FileOutputStream fos = new FileOutputStream(file+"\\1.jpg");
  40.                         FileOutputStream fos = new FileOutputStream(file+"\\"+fileName);
  41.                         //6.使用网络字节输入流InputStream对象中的方法read,读取客户端上传的文件
  43.                         int len =0;
  44.                         byte[] bytes = new byte[1024];
  45.                         while((len = is.read(bytes))!=-1){
  46.                             //7.使用本地字节输出流FileOutputStream对象中的方法write,把读取到的文件保存到服务器的硬盘上
  47.                             fos.write(bytes,0,len);
  48.                         }
  50.                         //8.使用Socket对象中的方法getOutputStream,获取到网络字节输出流OutputStream对象
  51.                         //9.使用网络字节输出流OutputStream对象中的方法write,给客户端回写"上传成功"
  52.                         socket.getOutputStream().write("上传成功".getBytes());
  53.                         //10.释放资源(FileOutputStream,Socket,ServerSocket)
  54.                         fos.close();
  55.                         socket.close();
  56.                     }catch (IOException e){
  57.                         System.out.println(e);
  58.                     }
  59.                 }
  60.             }).start();
  61.         }
  62.         //server.close();
  63.     }
  64. }

6.网络编程(TCP/IP)TCPClient

  1. import java.io.FileInputStream;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.OutputStream;
  5. import java.net.Socket;
  7. public class TCPClient {
  8.     public static void main(String[] args) throws IOException {
  9.         //1.创建一个本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
  10.         FileInputStream fis = new FileInputStream("c:\\1.jpg");
  11.         //2.创建一个客户端Socket对象,构造方法中绑定服务器的IP地址和端口号
  12.         Socket socket = new Socket("127.0.0.1",8888);
  13.         //3.使用Socket中的方法getOutputStream,获取网络字节输出流OutputStream对象
  14.         OutputStream os = socket.getOutputStream();
  15.         //4.使用本地字节输入流FileInputStream对象中的方法read,读取本地文件
  16.         int len = 0;
  17.         byte[] bytes = new byte[1024];
  18.         while((len = fis.read(bytes))!=-1){
  19.             //5.使用网络字节输出流OutputStream对象中的方法write,把读取到的文件上传到服务器
  20.             os.write(bytes,0,len);
  21.         }
  22.         /*
  23.             解决:上传完文件,给服务器写一个结束标记
  24.             void shutdownOutput() 禁用此套接字的输出流。
  25.          */
  26.         socket.shutdownOutput();
  27.         //6.使用Socket中的方法getInputStream,获取网络字节输入流InputStream对象
  28.         InputStream is = socket.getInputStream();
  29.         //7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
  30.         while((len = is.read(bytes))!=-1){
  31.             System.out.println(new String(bytes,0,len));
  32.         }
  33.         fis.close();
  34.         socket.close();
  35.     }
  36. }

7.字符串中随机选择一个字符python

  1. import random
  2. str1='this_a_string_with_several_characters'
  3. n=random.randint(0,len(str1))
  4. print(str1[n])#返回一个bai字符du串随机位置zhi的字符
  5. strs=['str1','str2','str3','str4','str5','str6']
  6. n=random.randint(0,len(strs))
  7. print(strs[n])#返回一个字符串数组随机位置的字符串

7.字符串乱序python

  1. import random
  2. a = [1,2,3,4,5]
  3. for i in range(10):
  4.     random.shuffle(a)
  5.     print(a)

7.使用StringBuilder拼接字符串（加速）

  1. public class StringTest {
  2.     public static void main(String[] args) {
  3.         String str1 = "hello ";
  4.         String str2 = "java";
  5.         String str3 = str1 + str2 + "!";
  6.         String str4 = new StringBuilder().append(str1).append(str2).append("!").toString();
  7.     }
  8.    // sb.toString() 转换成字符串
  10. }

IDEA OutOfMemoryError: Java heap space

8.查看虚拟机内存占用

  1. Runtime提供3个方法可以获取当前JVM最大可以使用内存、当前JVM已拥有最大内存和剩余未使用内存。这3个内存指的都是JVM堆内存。
  3. Runtime.maxMemory();
  4. Runtime.totalMemory();
  5. Runtime.freeMemory();

java cmd下带包编译带包运行

按住Ctrl点我

java给程序的main()方法传参

Java 类名 参数 参数 参数 ...      注：1.参数为字符串，2.参数数量[0,n]