Java最佳实践 on 菜鸟程序员

AES加解密

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.encryption;

import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;


/**
 * AES加密类
 *
 */
public class AESUtils {
 /**
 * 密钥算法
 */
 private static final String KEY_ALGORITHM = "AES";

 private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";

 /**
 * 初始化密钥
 *
 * @return byte[] 密钥
 * @throws Exception
 */
 public static byte[] initSecretKey() {
 // 返回生成指定算法的秘密密钥的 KeyGenerator 对象
 KeyGenerator kg = null;
 try {
 kg = KeyGenerator.getInstance(KEY_ALGORITHM);
 } catch (NoSuchAlgorithmException e) {
 e.printStackTrace();
 return new byte[0];
 }
 // 初始化此密钥生成器，使其具有确定的密钥大小
 // AES 要求密钥长度为 128
 kg.init(128);
 // 生成一个密钥
 SecretKey secretKey = kg.generateKey();
 return secretKey.getEncoded();
 }

 /**
 * 转换密钥
 *
 * @param key
 * 二进制密钥
 * @return 密钥
 */
 public static Key toKey(byte[] key) {
 // 生成密钥
 return new SecretKeySpec(key, KEY_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 密钥
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, Key key) throws Exception {
 return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 二进制密钥
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
 return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 二进制密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
 // 还原密钥
 Key k = toKey(key);
 return encrypt(data, k, cipherAlgorithm);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
 // 实例化
 Cipher cipher = Cipher.getInstance(cipherAlgorithm);
 // 使用密钥初始化，设置为加密模式
 cipher.init(Cipher.ENCRYPT_MODE, key);
 // 执行操作
 return cipher.doFinal(data);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 二进制密钥
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
 return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 密钥
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, Key key) throws Exception {
 return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 二进制密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
 // 还原密钥
 Key k = toKey(key);
 return decrypt(data, k, cipherAlgorithm);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
 // 实例化
 Cipher cipher = Cipher.getInstance(cipherAlgorithm);
 // 使用密钥初始化，设置为解密模式
 cipher.init(Cipher.DECRYPT_MODE, key);
 // 执行操作
 return cipher.doFinal(data);
 }

 public static String showByteArray(byte[] data) {
 if (null == data) {
 return null;
 }
 StringBuilder sb = new StringBuilder("{");
 for (byte b : data) {
 sb.append(b).append(",");
 }
 sb.deleteCharAt(sb.length() - 1);
 sb.append("}");
 return sb.toString();
 }

 /**
 * 将16进制转换为二进制
 *
 * @param hexStr
 * @return
 */
 public static byte[] parseHexStr2Byte(String hexStr) {

 if (hexStr.length() < 1)
 return null;
 byte[] result = new byte[hexStr.length() / 2];
 for (int i = 0; i < hexStr.length() / 2; i++) {
 int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
 int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
 result[i] = (byte) (high * 16 + low);
 }
 return result;
 }

 /**
 * 将二进制转换成16进制
 *
 * @param buf
 * @return
 */
 public static String parseByte2HexStr(byte buf[]) {
 StringBuffer sb = new StringBuffer();
 for (int i = 0; i < buf.length; i++) {
 String hex = Integer.toHexString(buf[i] & 0xFF);
 if (hex.length() == 1) {
 hex = '0' + hex;
 }
 sb.append(hex.toUpperCase());
 }
 return sb.toString();
 }

 /**
 * @param str
 * @param key
 * @return
 * @throws Exception
 */
 public static String aesEncrypt(String str, String key) throws Exception {
 if (str == null || key == null)
 return null;
 Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key.getBytes("utf-8"), "AES"));
 byte[] bytes = cipher.doFinal(str.getBytes("utf-8"));
 return Base64.getEncoder().encodeToString(bytes);
 }

 public static String aesDecrypt(String str, String key) throws Exception {
 if (str == null || key == null)
 return null;
 Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getBytes("utf-8"), "AES"));
 byte[] bytes = Base64.getDecoder().decode(str);
 bytes = cipher.doFinal(bytes);
 return new String(bytes, "utf-8");
 }

 public static void main(String[] args) throws Exception {



 // 指定key
 String base64Str1 = "cmVmb3JtZXJyZWZvcm1lcg==";
 byte[] bs = Base64.getDecoder().decode(base64Str1);
 System.out.println("base64Str1解密："+ Arrays.toString(bs));
 System.out.println("base64Str1解密：" + showByteArray(Base64.getDecoder().decode(base64Str1)));
 Key key1 = toKey(Base64.getDecoder().decode(base64Str1));

 String data1 = "{\"aaa\":\"bbb\"}";
 System.out.println("明文：" + data1);

 byte[] encryptData1 = encrypt(data1.getBytes(), key1);
 String encryptStr1=parseByte2HexStr(encryptData1);
 System.out.println("加密后数据1: byte[]:" + showByteArray(encryptData1));
 System.out.println("加密后数据1: Byte2HexStr:" + encryptStr1);
 System.out.println();

 byte[] encryptStrByte1 = parseHexStr2Byte(encryptStr1);
 byte[] decryptData1 = decrypt(encryptStrByte1, key1);
 System.out.println("解密后数据: byte[]:" + showByteArray(decryptData1));
 System.out.println("解密后数据: string:" + new String(decryptData1));


 System.out.println("--------------------------------------------------------");


 byte[] initKey = initSecretKey();
 System.out.println("key：" + Arrays.toString(Base64.getEncoder().encode(initKey)));
 System.out.println("key：" + showByteArray(initKey));
 Key key2 = toKey(initKey);

 String data2 = "{\"ccc\":\"ddd\"}";
 System.out.println("明文：" + data2);

 byte[] encryptData2 = encrypt(data2.getBytes(), key2);
 String encryptStr2=parseByte2HexStr(encryptData2);
 System.out.println("加密后数据1: byte[]:" + showByteArray(encryptData2));
 System.out.println("加密后数据1: Byte2HexStr:" + encryptStr2);
 System.out.println();

 byte[] encryptStrByte2 = parseHexStr2Byte(encryptStr2);
 byte[] decryptData2 = decrypt(encryptStrByte2, key2);
 System.out.println("解密后数据: byte[]:" + showByteArray(decryptData2));
 System.out.println("解密后数据: string:" + new String(decryptData2));

 }
}

fastjson

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.alibabafastjsondemo;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

import java.util.Map;

public class JsonToMapDemo1 {
 public static void main(String[] args){

 String str = "{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}";
 //第一种方式
 Map maps = (Map) JSON.parse(str);
 System.out.println("这个是用JSON类来解析JSON字符串!!!");
 for (Object map : maps.entrySet()){
 System.out.println(((Map.Entry)map).getKey()+" " + ((Map.Entry)map).getValue());
 }
 //第二种方式
 Map mapTypes = JSON.parseObject(str);
 System.out.println("这个是用JSON类的parseObject来解析JSON字符串!!!");
 for (Object obj : mapTypes.keySet()){
 System.out.println("key为："+obj+"值为："+mapTypes.get(obj));
 }
 //第三种方式
 Map mapType = JSON.parseObject(str,Map.class);
 System.out.println("这个是用JSON类,指定解析类型，来解析JSON字符串!!!");
 for (Object obj : mapType.keySet()){
 System.out.println("key为："+obj+"值为："+mapType.get(obj));
 }
 //第四种方式

 Map json = (Map) JSONObject.parse(str);
 System.out.println("这个是用JSONObject类的parse方法来解析JSON字符串!!!");
 for (Object map : json.entrySet()){
 System.out.println(((Map.Entry)map).getKey()+" "+((Map.Entry)map).getValue());
 }
 //第五种方式

 JSONObject jsonObject = JSONObject.parseObject(str);
 System.out.println("这个是用JSONObject的parseObject方法来解析JSON字符串!!!");
 for (Object map : json.entrySet()){
 System.out.println(((Map.Entry)map).getKey()+" "+((Map.Entry)map).getValue());
 }
 //第六种方式

 Map mapObj = JSONObject.parseObject(str,Map.class);
 System.out.println("这个是用JSONObject的parseObject方法并执行返回类型来解析JSON字符串!!!");
 for (Object map: json.entrySet()){
 System.out.println(((Map.Entry)map).getKey()+" "+((Map.Entry)map).getValue());
 }
 String strArr = "{{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}," +
 "{\"00\":\"zhangsan\",\"11\":\"lisi\",\"22\":\"wangwu\",\"33\":\"maliu\"}}";
 // JSONArray.parse()
 System.out.println(json);

 }
}

最终输出结果为：

Integer比较

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.intandinteger;


// java 9 以后 此初始化已经标记为废弃，推荐使用 Integer.valueOf("100");
public class IntegerTest {
 public static void main(String[] args) {
 int a = 100;

 Integer b = 100;
 if ( a == b ) {
 //原因是由于此区间的只都是由IntegerCache.cache而来，具体查看Integer.valueOf(n)方法
 //其中IntegerCache.cache static final Integer cache[];
 System.out.println("-128 - 127 之间的int类型是在常量池中, ");
 }


 // 但是 Integer.valueOf("100");
 Integer c = Integer.valueOf("300");
 Integer d = Integer.valueOf("300");
 if ( c != d ) {
 System.out.println("Integer.valueOf(\"100\") 初始化的127以上的数字是放到推空间的");
 }


 Integer e = Integer.valueOf("100");
 Integer f = Integer.valueOf("100");
 if ( e == f ) {
 System.out.println("Integer.valueOf(\"100\") 初始化的127以内的还是从常量池中获取");
 }

 Integer g = Integer.valueOf("400");
 int h = 400;
 if ( g == h ) {
 System.out.println("Integer会向下转型");
 }

 }
}

Java的参数是值传递

Mon, 01 Jan 0001 00:00:00 +0000

class User

package cn.anzhongwei.lean.demo.java传参;

public class User {
 private String name;
 private String Gender;

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public String getGender() {
 return Gender;
 }

 public void setGender(String gender) {
 Gender = gender;
 }
}

package cn.anzhongwei.lean.demo.java传参;

/**
 * 要理解java的传参
 * 结果：
 主类中实例化user1-hash:cn.anzhongwei.demo.java传参.User@4d7e1886
 主类中实例化参数:Name=Hollis
 方法中接受到参数user-hash:cn.anzhongwei.demo.java传参.User@4d7e1886 // 与main函数同一个对象
 方法中重新实例化参数user-hash:cn.anzhongwei.demo.java传参.User@3cd1a2f1 // 产生新对象，但是只在局部有效
 方法中重新实例化参数:Name=hollischuang
 经过方法后的user1-hashcn.anzhongwei.demo.java传参.User@4d7e1886 //user1并没有因为在函数中局部参数实例化而发生变化
 经过方法后的参数xiaoming //实例属性会被函数中的更改而发生变化
 */
public class PassOn {
 public void pass(User user) {
 System.out.println("方法中接受到参数user-hash:"+user);
 user.setName("xiaoming");


 user = new User();
 user.setName("hollischuang");
 System.out.println("方法中重新实例化参数user-hash:"+user);
 System.out.println("方法中重新实例化参数:Name="+user.getName());
 }
 public static void main(String[] args) {
 PassOn pt = new PassOn();

 User user1 = new User();
 System.out.println("主类中实例化user1-hash:"+user1);
 user1.setName("Hollis");
 user1.setGender("Male");
 System.out.println("主类中实例化参数:Name="+user1.getName());
 pt.pass(user1);
 System.out.println("经过方法后的user1-hash" + user1);
 System.out.println("经过方法后的参数" + user1.getName());
 }

}

Optional

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.optional;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Optional;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
 private String name;
 private Integer age;
 private Address address;

 public Person(String name, Integer age) {
 this.name = name;
 this.age = age;
 }

 public Optional<String> optionalGetName() {
 return Optional.ofNullable(this.name);
 }
}

package cn.anzhongwei.lean.demo.optional;

import lombok.Data;

@Data
public class Address {
 private String city;
 private String addInfo;
}

package cn.anzhongwei.lean.demo.optional;

import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

public class OptionalTest {

 /**
 * Optional(T value),empty(),of(T value),ofNullable(T value)
 * Optional(T value) 是private的属于内部方法
 */
 @Test
 public void test1() {
 //of(T value) 是实际上调用了Optional(T value) 而其内部的requireNonNull方法源码中判断value==null时会抛出空指针异常
 //在开发中如果不想隐藏空指针异常时 使用of函数， 不过这种情况几乎不用
 //Optional<Person> p1 = Optional.of(null);

 //所以如果要创建一个value为null的Optional对象则应该使用 empty()
 Optional<Person> pnull = Optional.empty();
 //而ofNullable(T value) 则是一个三元表达式 return value == null ? empty() : of(value);
 Optional<Person> p0 = Optional.ofNullable(null);
 Optional<Person> p1 = Optional.ofNullable(new Person("zhangs", 20));
 }

 /**
 * orElse(T other)，orElseGet(Supplier other)和orElseThrow(Supplier exceptionSupplier)
 * 这三个函数放一组进行记忆，都是在构造函数传入的value值为null时，进行调用的。
 * orElse 和 orElseGet 没区别 可以认为时完全一样的代码
 *
 * orElseThrow 则会当value为空时抛出一个自定义异常
 */
 @Test
 public void test2() {
 Person p = null;
 //当p值不为null时，orElse函数依然会执行createUser()方法
 p = Optional.ofNullable(p).orElse(new Person("zhangsan", 20));
 System.out.println("调用orElse 当p为null时:"+p);
 //而当p不为空，则相当于使用get()方法
 p = Optional.ofNullable(p).orElse(new Person("王五", 60));
 System.out.println("调用orElse 此时p不为null时:"+p);
 //
 p = null;
 //重新赋值p=null
 System.out.println("重新赋值p=:"+p);
 p = Optional.ofNullable(p).orElseGet(() -> new Person("lisi", 30));
 System.out.println("orElseGet 当p为null时:"+p);
 p = Optional.ofNullable(p).orElseGet(() -> new Person("zhaoliu", 34));
 System.out.println("orElseGet 此时p不为null时:"+p);


 }
 @Test
 public void testOrElseThrow() {
 Person p = new Person("lisi", 30);
 p = Optional.ofNullable(p).orElseThrow(()-> new RuntimeException("用户不存在"));
 System.out.println("orElseThrow 此时p不为null时:"+p);
 p = null;
 p = Optional.ofNullable(p).orElseThrow(()-> new RuntimeException("用户不存在"));
 }

 /**
 * map(Function mapper)和flatMap(Function> mapper)
 * 这两个函数做的是转换值的操作
 */
 @Test
 public void test3() {
 Person p = new Person("lisi", 30);
 String name = Optional.ofNullable(p).map( person -> person.getName()).get();
 System.out.println("name="+name);

 String optionalName = Optional.ofNullable(p).flatMap(person -> person.optionalGetName()).get();
 System.out.println("optionalName="+optionalName);
 }

 /**
 * isPresent()和ifPresent(Consumer consumer)
 * isPresent即判断value值是否为空，而ifPresent就是在value值不为空时，做一些操作。
 */
 @Test
 public void test4() {
 Person p = null;
 Optional.ofNullable(p).ifPresent(person -> {

 });
 }

 /**
 * filter(Predicate predicate)
 */
 @Test
 public void test5() {
 Person p = null;
 //如果 p.name 长度小于6则返回， 否则返回EMPTY
 Optional<Person> p1 = Optional.ofNullable(p).filter(u -> u.getName().length()<6);
 }

 /**
 * 实战写法1
 */
 public String getCity(Person person) throws Exception{
 if(person!=null){
 if(person.getAddress()!=null){
 Address address = person.getAddress();
 if(address.getCity()!=null){
 return address.getCity();
 }
 }
 }
 throw new RuntimeException("取值错误");
 }
 public String getCity2(Person person) throws Exception{
 return Optional.ofNullable(person)
 .map(u-> u.getAddress())
 .map(a->a.getCity())
 .orElseThrow(()->new Exception("取值错误"));
 }

 /**
 * 实战写法2
 */
 public void dosomething(Person person) {
 if (Objects.nonNull(person)) {
 //......
 }
 Optional.ofNullable(person).ifPresent(person1 -> {
 //......
 });
 }

 /**
 * 实战写法3
 */
 public Person getUser1(Person user){
 if(user!=null){
 String name = user.getName();
 if(!"zhangsan".equals(name)){
 user = new Person();
 user.setName("zhangsan");
 }
 }else{
 user = new Person();
 user.setName("zhangsan");
 }
 return user;
 }
 public Person getUser2(Person user) {
 return Optional.ofNullable(user)
 .filter(u->"zhangsan".equals(u.getName()))
 .orElseGet(()-> {
 Person user1 = new Person();
 user1.setName("zhangsan");
 return user1;
 });
 }



 public Person getUser3(Person user){
 if(user!=null){
 String name = user.getName();
 if(!"zhangsan".equals(name)){
 user.setName("zhangsan");
 }
 }else{
 user = new Person();
 user.setName("zhangsan");
 }
 return user;
 }
 public Person getUser4(Person user) {
 //这个逻辑一般来说不会这么写， 大多数情况下都是不为空且不为zhangsan时， 将name赋值成zhangsan，而不是重新实例化
 return Optional.ofNullable(user)
 .filter(u->"zhangsan".equals(u.getName()))
 .orElseGet(()-> {
 if (Objects.nonNull(user)) {
 user.setName("zhangsan");
 return user;
 } else {
 Person user1 = new Person();
 user1.setName("zhangsan");
 return user1;
 }


 });
 }
 @Test
 public void test6() {
 //getUser1 和 getUser2 只要name不等于 zhangsan， 就重新初始化
 Person p = new Person("wangwu", 26);
 Person p1 = getUser1(p);
 System.out.println("p1:"+p1);

 p = new Person("lisi", 23);
 Person p2 = getUser2(p);
 System.out.println("p2:"+p2);

 //getUser3 和 getUser4 name不等于 zhangsan， 只改变name=张三， 其他内容不变
 p = new Person("zhaosi", 26);
 Person p3 = getUser3(p);
 System.out.println("p3:"+p3);

 p = new Person("liuqi", 26);
 Person p4 = getUser4(p);
 System.out.println("p4:"+p4);
 }


 @Test
 public void test7() {
 List<Person> personList = new ArrayList<>();
 Person p1 = new Person("zhangsan", 22);personList.add(p1);
 Person p2 = new Person("zhaosi", 29);personList.add(p2);
 Person p3 = new Person("wangwu", 22);personList.add(p3);
 Person p4 = new Person("lisen", 35);personList.add(p4);
 Person p5 = new Person("liuming", 248);personList.add(p5);

 Optional<Person> personOptional = personList.stream().filter(p -> p.getAge() > 22).findFirst();
 Person pp1 = personOptional.orElseGet(() -> personList.get(0));
 System.out.println(pp1);
 Person pp2 = personOptional.orElse(null);
 System.out.println(pp2);

 List<Person> personList2 = Optional.ofNullable(personList).orElseGet(ArrayList::new);
 System.out.println(personList2);

 Map<String, List<Person>> pMap = new HashMap<>();
// List<Person> personList3 = Optional.ofNullable(pMap.get("随便写"))
// //这种写法主要为了后面stream()的流式处理方式不会有空指针
// //这样会空指针
// .get()
// .stream().collect(Collectors.toList());
// System.out.println(personList3);

 List<Person> personList4 = Optional.ofNullable(pMap.get("随便写"))
 //这种写法主要为了后面stream()的流式处理方式不会有空指针
 .orElseGet(ArrayList::new)
 .stream().collect(Collectors.toList());
 System.out.println(personList4);
 }


}

PDF转图片

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.pdftoimg;

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.ImageType;
import org.apache.pdfbox.rendering.PDFRenderer;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class PdfUtil {
 public static void main(String[] args) {
 String source = "C:\\Home\\22.pdf";
 String desFileName = "invoice";
 String desFilePath = "C:\\Home\\ddd";
 String imageType = "png";
 Long t1 = System.currentTimeMillis();
 List<String> pair = PdfUtil.pdfToImg(source, desFilePath, desFileName, imageType);
 Long t2 = System.currentTimeMillis();
 System.out.println(t2-t1);
 pair.forEach(System.out::println);


 }

 public static List<String> pdfToImg(String source, String desFilePath, String desFileName, String imageType) {
 //通过给定的源路径名字符串创建一个File实例
 File file = new File(source);
 if (!file.exists()) {
 throw new RuntimeException("文件不存在，无法转化");
 }
 //目录不存在则创建目录
 File destination = new File(desFilePath);
 if (!destination.exists()) {
 boolean flag = destination.mkdirs();
 System.out.println("创建文件夹结果：" + flag);
 }
 PDDocument doc = null;
 try {
 //加载PDF文件
 doc = PDDocument.load(file);
 PDFRenderer renderer = new PDFRenderer(doc);
 //获取PDF文档的页数
 int pageCount = doc.getNumberOfPages();
 System.out.println("文档一共" + pageCount + "页");
 List<String> fileList = new ArrayList<>();
 for (int i = 0; i < pageCount; i++) {
 //只有一页的时候文件名为传入的文件名，大于一页的文件名为：文件名_自增加数字(从1开始)
 String realFileName = pageCount > 1 ? desFileName + "_" + (i + 1) : desFileName;
 //每一页通过分辨率和颜色值进行转化
 BufferedImage bufferedImage = renderer.renderImageWithDPI(i, 96*2, ImageType.RGB);
 String filePath = desFilePath + File.separator + realFileName + "." + imageType;
 //写入文件
 ImageIO.write(bufferedImage, imageType, new File(filePath));
 //文件名存入list
 fileList.add(filePath);
 }
 return fileList;
 } catch (IOException e) {
 e.printStackTrace();
 throw new RuntimeException("PDF转化图片异常，无法转化");
 } finally {
 try {
 if (doc != null) {
 doc.close();
 }
 } catch (IOException e) {
 System.out.println("关闭文档失败");
 e.printStackTrace();
 }
 }

 }
}

Serializable序列化

Mon, 01 Jan 0001 00:00:00 +0000

Person

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;

import java.io.Serializable;

@Data
@ToString
@AllArgsConstructor
public class Person implements Serializable {
 private String name;
 private int age;
}

Teacher

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;

import java.io.Serializable;

@Data
@ToString
@AllArgsConstructor
public class Teacher implements Serializable {
 private String name;
 private Person person;
}

写序列化到文件

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

// TODO 还没测试成功
public class WriteObject {
 public static void main(String[] args) {
// try (//创建一个ObjectOutputStream输出流
// ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Home\\teacher.txt"))) {
// //将对象序列化到文件s
// Person person = new Person("9龙", 23);
// Teacher teacher = new Teacher("路飞", person);
// oos.writeObject(teacher);
// } catch (Exception e) {
// e.printStackTrace();
// }

 try (//创建一个ObjectOutputStream输出流
 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\teacher2.txt"))) {
 //将对象序列化到文件s
 Person person = new Person("路飞", 20);
 Teacher t1 = new Teacher("雷利", person);
 Teacher t2 = new Teacher("红发香克斯", person);
 //依次将4个对象写入输入流
 oos.writeObject(t1);
 oos.writeObject(t2);
 System.out.println(t2.hashCode());
 oos.writeObject(person);
 oos.writeObject(t2);
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
}

从文件读序列化并实例化

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ReadObject {
 public static void main(String[] args) {
// try (//创建一个ObjectInputStream输入流
// ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Home\\teacher.txt"))) {
// Teacher teacher = (Teacher) ois.readObject();
// System.out.println(teacher);
// } catch (Exception e) {
// e.printStackTrace();
// }

 try (//创建一个ObjectInputStream输入流
 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\teacher2.txt"))) {
 Teacher t1 = (Teacher) ois.readObject();
 Teacher t2 = (Teacher) ois.readObject();
 Person p = (Person) ois.readObject();
 Teacher t3 = (Teacher) ois.readObject();
 System.out.println(t1 == t2);
 System.out.println(t1.getPerson() == p);
 System.out.println(t2.getPerson() == p);
 System.out.println(t2 == t3);
 System.out.println(t2.hashCode());
 System.out.println(t3.hashCode());
 System.out.println(t1.getPerson() == t2.getPerson());
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
}

SimpleFTPClient

Mon, 01 Jan 0001 00:00:00 +0000


import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Base64;
import java.util.LinkedList;
import java.util.List;


import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
<!--apacheftp-->
<!--导入commons-net依赖-->
<!--https://mvnrepository.com/artifact/commons-net/commons-net-->
<dependency>
 <groupId>commons-net</groupId>
 <artifactId>commons-net</artifactId>
 <version>3.6</version>
</dependency>

<!-- 引入Apache的commons-lang3包，方便操作字符串-->
<!--https://mvnrepository.com/artifact/org.apache.commons/commons-lang3-->
<dependency>
 <groupId>org.apache.commons</groupId>
 <artifactId>commons-lang3</artifactId>
 <version>3.8</version>

</dependency>

<!--引入Apachecommons-io包，方便操作文件-->
<!--https://mvnrepository.com/artifact/commons-io/commons-io-->
<dependency>
 <groupId>commons-io</groupId>
 <artifactId>commons-io</artifactId>
 <version>2.6</version>
</dependency>
*/

public class SimpleFTPClient {
 private static final Logger logger = LoggerFactory.getLogger(SimpleFTPClient.class);
 private static FTPClient connectFtpServer(String url,String userName,String password){

 String str = url.replaceFirst("ftp://", "").replaceFirst("FTP://", "");
 str=str.replaceAll("/+", "/");
 int endIndex = str.indexOf("/");
 str = str.substring(0,endIndex);
 url = str;//"ftp://"+str+"/";

 String[] addr = url.split(":");
 FTPClient ftpClient = new FTPClient();
 ftpClient.setConnectTimeout(1000*5);//设置连接超时时间
 // ftpClient.setControlEncoding("GBK"); 
 ftpClient.setControlEncoding("utf-8");//设置ftp字符集
 ftpClient.enterLocalPassiveMode();//设置被动模式，文件传输端口设置
 try {
 
 ftpClient.connect(addr[0],Integer.parseInt(addr[1]));
 
 if(null==userName||"".equals(userName)){
 userName = "anonymous";
 password = "password";
 }
 boolean isLoginSuccess = ftpClient.login(userName,password);
 logger.info("isLoginSuccess="+isLoginSuccess);

 ftpClient.setFileType(FTP.BINARY_FILE_TYPE);//设置文件传输模式为二进制，可以保证传输的内容不会被改变

 int replyCode = ftpClient.getReplyCode();
 if (!FTPReply.isPositiveCompletion(replyCode)){
 logger.error("connect ftp {} failed",url);
 ftpClient.abort();
 ftpClient.disconnect();
 return null;
 }
 logger.info("replyCode==========={}",replyCode);
 } catch (IOException e) {
 logger.error("connect fail ------->>>{}",e);
 return null;
 }
 return ftpClient;
}
 /**
 *
 * @param inputStream 待上传文件的输入流
 * @param originName 文件保存时的名字
 */
 public void uploadFile(String url,String userName,String password,InputStream inputStream, String originName){
 FTPClient ftpClient = connectFtpServer(url,userName,password);
 if (ftpClient == null){
 return;
 }
 
 /* try {
 ftpClient.changeWorkingDirectory(remoteDir);//进入到文件保存的目录
 Boolean isSuccess = ftpClient.storeFile(originName,inputStream);//保存文件
 if (!isSuccess){
 throw new BusinessException(ResponseCode.UPLOAD_FILE_FAIL_CODE,originName+"---》上传失败！");
 }
 logger.info("{}---》上传成功！",originName);
 ftpClient.logout();
 } catch (IOException e) {
 logger.error("{}---》上传失败！",originName);
 throw new BusinessException(ResponseCode.UPLOAD_FILE_FAIL_CODE,originName+"上传失败！");
 }finally {
 if (ftpClient.isConnected()){
 try {
 ftpClient.disconnect();
 } catch (IOException e) {
 logger.error("disconnect fail ------->>>{}",e.getCause());
 }
 }
 } */
 }
/**
 * 读ftp上的文件，并将其转换成base64
 * @param remoteFileName ftp服务器上的文件名
 * @return
 */
 public static String readFileToBase64(String url,String userName,String password){
 logger.info("url={}",url);
 FTPClient ftpClient = connectFtpServer(url,userName,password);
 if (ftpClient == null){
 return null;
 }
 logger.info("ftpClient={}",ftpClient.isAvailable()&&ftpClient.isConnected());
 String base64 = "";
 InputStream inputStream = null;
 ByteArrayOutputStream os=null;
 String remoteDir;
 String str = url.replaceFirst("ftp://", "").replaceFirst("FTP://", "");
 str=str.replaceAll("/+", "/");
 int beginIndex = str.indexOf("/");
 int endIndex = str.lastIndexOf("/");
 remoteDir=str.substring(beginIndex,endIndex+1);
 logger.info("remoteDir={}",remoteDir);
 String remoteFileName = str.substring(endIndex+1);
 logger.info("remoteFileName={}",remoteFileName);
 try {
 boolean chDirRes = ftpClient.changeWorkingDirectory(remoteDir);
 logger.info("changeWorkingDirectory={}",chDirRes);
 ftpClient.enterLocalPassiveMode();
 FTPFile[] ftpFiles = ftpClient.listFiles(remoteDir);
 logger.info("ftpFiles.length={}",ftpFiles.length);
 Boolean flag = false;
 //遍历当前目录下的文件，判断要读取的文件是否在当前目录下
 for (FTPFile ftpFile:ftpFiles){
 if (ftpFile.getName().equals(remoteFileName)){
 flag = true;
 break;
 }
 }

 if (!flag){
 logger.error("directory：{}下没有 {}",remoteDir,remoteFileName);
 return null;
 }

 /* // 下载ftp上指定文件到本地
 File localFile = new File("D:" + File.separator +"abc_"+ remoteFileName);
 boolean downloaded = ftpClient.retrieveFile(remoteFileName,
 new FileOutputStream(localFile));
 
 System.out.println(ftpClient.getReplyString()); */




 logger.info("开始获取文件流");
 //获取待读文件输入流
 inputStream = ftpClient.retrieveFileStream(remoteFileName); // remoteDir+remoteFileName

 // //inputStream.available() 获取返回在不阻塞的情况下能读取的字节数，正常情况是文件的大小
 logger.info("完成获取文件流");
 byte[] bytes = new byte[1024];
 os = new ByteArrayOutputStream();
 int len=-1;
 while( (len=inputStream.read(bytes))!=-1){//将文件数据读到字节数组中
 os.write(bytes, 0, len);
 }
 os.flush();
 byte[] fileBytes = os.toByteArray();
 
 /* File file = new File("d:/"+remoteFileName);
 OutputStream fos = new FileOutputStream(file);
 try {
 fos.write(fileBytes);
 fos.flush();
 } catch (Exception e) {
 //TODO: handle exception
 }
 finally{
 fos.close();
 } */
 

 int fileSize = fileBytes.length;
 logger.info("fileSize={}",fileSize);
 Base64.Encoder encoder = Base64.getEncoder();
 base64 = encoder.encodeToString(fileBytes);
 logger.debug("base64 img="+base64);
 logger.info("read file {} success",remoteFileName);

 if(!ftpClient.completePendingCommand()) {
 ftpClient.logout();
 ftpClient.disconnect();
 logger.error("File transfer failed.");
 return null;
 }

 ftpClient.logout();
 } catch (IOException e) {
 logger.error("read file fail ----->>>{}",e.getCause());
 return null;
 }finally {
 if (ftpClient.isConnected()){
 try {
 ftpClient.disconnect();
 } catch (IOException e) {
 logger.error("disconnect fail ------->>>{}",e.getCause());
 }
 }

 if (inputStream != null){
 try {
 inputStream.close();
 } catch (IOException e) {
 logger.error("inputStream close fail -------- {}",e.getCause());
 }
 }

 if (os != null){
 try {
 os.close();
 } catch (IOException e) {
 logger.error("os close fail -------- {}",e.getCause());
 }
 }

 }

 return base64;

 }
/**
 * 文件下载
 * @param remoteFileName ftp上的文件名
 * @param localFileName 本地文件名
 */
 public void download(String url,String userName,String password,String remoteFileName,String localFileName){
 FTPClient ftpClient = connectFtpServer(url,userName,password);
 if (ftpClient == null){
 return ;
 }

 OutputStream outputStream = null;

 /* try {
 ftpClient.changeWorkingDirectory(remoteDir);
 FTPFile[] ftpFiles = ftpClient.listFiles(remoteDir);
 Boolean flag = false;
 //遍历当前目录下的文件，判断是否存在待下载的文件
 for (FTPFile ftpFile:ftpFiles){
 if (ftpFile.getName().equals(remoteFileName)){
 flag = true;
 break;
 }
 }

 if (!flag){
 logger.error("directory：{}下没有 {}",remoteDir,remoteFileName);
 return ;
 }

 outputStream = new FileOutputStream(localDir+localFileName);//创建文件输出流

 Boolean isSuccess = ftpClient.retrieveFile(remoteFileName,outputStream); //下载文件
 if (!isSuccess){
 logger.error("download file 【{}】 fail",remoteFileName);
 }

 logger.info("download file success");
 ftpClient.logout();
 } catch (IOException e) {
 logger.error("download file 【{}】 fail ------->>>{}",remoteFileName,e.getCause());
 }finally {
 if (ftpClient.isConnected()){
 try {
 ftpClient.disconnect();
 } catch (IOException e) {
 logger.error("disconnect fail ------->>>{}",e.getCause());
 }
 }

 if (outputStream != null){
 try {
 outputStream.close();
 } catch (IOException e) {
 logger.error("outputStream close fail ------->>>{}",e.getCause());
 }
 }
 } */
 }

 public static void main(String[] args) {
 // String ftpPath = "ftp://192.168.1.3:8010/recordsImg/2019-05-31/STRANGERBABY_1559265983072.jpg";
 // readFileToBase64(ftpPath,"","");
 String url="ftp://106.12.195.197:21/";
 FTPClient ftpClient = connectFtpServer(url,"myftp","123456");
 if (ftpClient == null){
 return ;
 }
 logger.info("ftpClient={}",ftpClient.isAvailable()&&ftpClient.isConnected());
 String base64 = "";
 InputStream inputStream = null;
 ByteArrayOutputStream os=null;
 String remoteDir;
 String str = url.replaceFirst("ftp://", "").replaceFirst("FTP://", "");
 str=str.replaceAll("/+", "/");
 int beginIndex = str.indexOf("/");
 // int endIndex = str.lastIndexOf("/");
 
 // remoteDir=str.substring(beginIndex,endIndex+1);
 String remotePath =str.substring(beginIndex);
 logger.info("remotePath={}",remotePath);
 String status="nil";
 try {
 status=ftpClient.getStatus(remotePath);
 } catch (Exception e) {
 //TODO: handle exception
 e.printStackTrace();
 }
 logger.info("ftpClient.getStatus={}",status);
 
 try {
 // boolean chDirRes = ftpClient.changeWorkingDirectory(remoteDir);
 // logger.info("changeWorkingDirectory={}",chDirRes);
 // ftpClient.enterLocalPassiveMode();
 /* FTPFile[] ftpFiles = ftpClient.listFiles(remoteDir);
 logger.info("ftpFiles.length={}",ftpFiles.length);
 Boolean flag = false;
 //遍历当前目录下的文件，判断要读取的文件是否在当前目录下
 for (FTPFile ftpFile:ftpFiles){
 logger.info("ftpFiles------{}",ftpFile.getName());
 } */
 // boolean renameRes = ftpClient.rename("/imgfacebak/bb1.png", "/test/a.png");
 // logger.info("renameRes={}",renameRes);
 // if(!ftpClient.completePendingCommand()) {
 // ftpClient.logout();
 // ftpClient.disconnect();
 // logger.error("File transfer failed.");
 // return ;
 // }

 ftpClient.logout();
 
 } catch (IOException e) {
 logger.error("read file fail ----->>>{}",e.getCause());
 return ;
 }finally {
 if (ftpClient.isConnected()){
 try {
 ftpClient.disconnect();
 } catch (IOException e) {
 logger.error("disconnect fail ------->>>{}",e.getCause());
 }
 }

 

 }

 




 }

}

Stream API示例

Mon, 01 Jan 0001 00:00:00 +0000

import lombok.Data;
import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPI {

 /**
 *
 * Comparator.reverseOrder()是让某个条件进行倒序排序.
 * reversed()是让他前面的字段进行倒序。
 *
 * 例如：Comparator.comparing（名称）.reversed()，此时名称倒序；
 * Comparator.comparing（名称）.thenComparing(状态).reversed()，此时名称和状态进行倒序。
 *
 * Comparator.comparing（名称）.thenComparing(状态).reversed().thenComparing(年龄)，此时名称和状态会倒序，年龄会升序。
 *
 * 加多个.reversed()
 * Comparator.comparing（状态）.reversed().thenComparing(年龄).reversed()，最终结果是只有年龄倒排，状态未排序

 */

 /**
 * 练习1：让年龄进行倒序排序。
 */
 @Test
 public void test1() {
 /*
 * Comparator.comparing（放实体类名称::放列名）：添加排序字段；
 * reversed()：倒序。
 * collect(Collectors.toList())：转成集合。
 * forEach(System.out::println)：打印循环。
 */
 List<User> userList = generatorUserList();
// userList.stream()
// .sorted(Comparator.comparing(User::getAge).reversed())//reversed()是让其前面得所有字段都倒排
// .collect(Collectors.toList())
// .forEach(System.out::println);


// List<User> userList2 = generatorUserList();
// userList2.stream()
// .sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder()))//Comparator.reverseOrder()是让某个条件进行倒序排序
// .collect(Collectors.toList()).forEach(System.out::println);

 userList.stream().sorted(Comparator.comparing(User::getAge).reversed())
 .collect(Collectors.toList()).forEach(System.out::println);
 }

 /**
 * 练习2：让使用状态进行升序排序。
 */
 @Test
 public void test2() {
 List<User> userList = generatorUserList();
 //默认是升序，所以只需要把排序字段放进去就行了。
 userList.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList()).forEach(System.out::println);
 }

 /**
 * 练习3：让使用先状态和后年龄都进行倒序排序。
 */
 @Test
 public void test3() {
 List<User> userList = generatorUserList();
 userList.stream()
 //先根据使用状态倒序，而王五使用状态为2，所以王五排在第一。
 //而李四和张三使用状态都是1，就会触发另一个排序条件根据年龄排序
 .sorted(Comparator.comparing(User::getState).thenComparing(User::getAge).reversed())
 .collect(Collectors.toList())
 .forEach(System.out::println);

 //写法2
 List<User> userList2 = generatorUserList();
 userList2.stream()
 .sorted(
 Comparator.comparing(User::getState, Comparator.reverseOrder())//根据state倒排
 .thenComparing(User::getAge, Comparator.reverseOrder())//根据age倒排
 )
 .forEach(System.out::println);
 }

 /**
 * 练习4：让使用状态和年龄都进行升序排序。
 */
 @Test
 public void test4() {
 List<User> userList = generatorUserList();
 //默认就是升序
 userList.stream().sorted(Comparator.comparing(User::getState).thenComparing(User::getAge)).forEach(System.out::println);
 }

 /**
 * 练习5：让使用状态进行升序排序，年龄进行倒序排序，创建时间进行倒序排序。名字正排序
 * 注意：假如多个排序条件的排序方向不一致，需要倒序的字段应该用Comparator.reverseOrder(),每个倒排得字段单独写。
 */
 @Test
 public void test5() {
 List<User> userList = generatorUserList();
 userList.stream()
 .sorted(
 Comparator.comparing(User::getState)
 .thenComparing(User::getAge, Comparator.reverseOrder())
 .thenComparing(User::getCreateTime,Comparator.reverseOrder())
 .thenComparing(User::getName)
 )
 .forEach(System.out::println);
 }

 /**
 * 练习6，按 State 分组 组成 Map<Ingeter, List<User>>的结构
 */
 @Test
 public void test6() {
 List<User> userList = generatorUserList();
 Map<Integer, List<User>> stateToUserList = userList.stream().collect(Collectors.groupingBy(User::getState));
 System.out.println(stateToUserList);
 }

 /**
 * 联系7 根据姓名作为key， User对象为val，组成map<String, User>
 * 如果是根据state， 因为元素不唯一， 所以会抛出异常
 * 根据姓名为key， age为val组成 map<String, Ingeter>
 */
 @Test
 public void test7() {
 List<User> userList = generatorUserList();
 Map<String, User> nameToUser = userList.stream().collect(Collectors.toMap(User::getName, user -> user));
 //下面这样也行
// Map<String, User> nameToUser = userList.stream().collect(Collectors.toMap(User::getName, user -> {return user;}));
 System.out.println(nameToUser);

 //在映射时， 把年龄加1再返回
 Map<String, User> nameToAge0 = userList.stream().collect(Collectors.toMap(User::getName, user -> { user.setAge(user.age+1); return user;}));
 System.out.println(nameToAge0);

 //那么如果分组的字段是一个非唯一的，比如state， 会报错
// Map<Integer, User> stateToUser = userList.stream().collect(Collectors.toMap(User::getState, user -> user));
// System.out.println(stateToUser);

 //根据姓名为key， age为val组成 map<String, Ingeter>
 //写法1
 Map<String, Integer> nameToAge = userList.stream().collect(Collectors.toMap(User::getName, User::getAge));
 System.out.println(nameToAge);
 //写法2
 Map<String, Integer> nameToAge2 = userList.stream().collect(Collectors.toMap(User::getName, user -> {return user.age;}));
 System.out.println(nameToAge2);

 Map<String, Integer> nameToAge3 = userList.stream().collect(Collectors.toMap(User::getName, user -> { user.setAge(user.age+1); return user.age;}));
 System.out.println(nameToAge3);

 }

 /**
 * 练习8 按名字去重
 */
 @Test
 public void test8() {
 List<User> userList = generatorUserList();
 Set<String> collect1 = userList.stream().distinct().map(User::getName).collect(Collectors.toSet());
 System.out.println(collect1);
 return;
 }

 /**
 * 按名字统计数量
 */
 @Test
 public void test9() {
 List<User> userList = generatorUserList();
 Map<String, Long> collect = userList.stream().collect(Collectors.groupingBy(User::getName, Collectors.counting()));
 System.out.println(collect);
 return;
 }

 /**
 * 求年龄最大值、最小值
 */
 @Test
 public void test10() {
 List<User> userList = generatorUserList();
 //如果有年龄一样的，会按list顺序取第一条, 所以除非能唯一， 否则多维度需要使用排序来获取值
 Optional<User> min = userList.stream().min(Comparator.comparing(User::getAge));
 System.out.println("min = " + min);
 }

 /**
 * 获取某个字段的 最大值、最小值、求和、统计、计数
 */
 @Test
 public void test11() {
 List<User> userList = generatorUserList();
 IntSummaryStatistics collect = userList.stream().collect(Collectors.summarizingInt(User::getAge));
 double average = collect.getAverage();
 int max = collect.getMax();
 int min = collect.getMin();
 long sum = collect.getSum();
 long count = collect.getCount();
 System.out.println("collect = " + collect);

 //单独对某个字段汇总
 int sum1 = userList.stream().mapToInt(User::getAge).sum();
 System.out.println("sum = " + sum1);

 double avg1 = userList.stream().collect(Collectors.averagingDouble(User::getAge));
 System.out.println("avg1 = " + avg1);

 OptionalDouble avg2 = userList.stream().mapToDouble(User::getAge).average();
 if (avg2.isPresent()) {
 System.out.println("avg2 = " + avg2);
 }
 }

 /**
 * 按名字分组， 统计年龄相关的 计数， 总数，最大，最小，平均
 */
 @Test
 public void test12() {
 List<User> userList = generatorUserList();
 Map<String, IntSummaryStatistics> collect = userList.stream().collect(Collectors.groupingBy(User::getName, Collectors.summarizingInt(User::getAge)));
 for(Map.Entry<String, IntSummaryStatistics> entry : collect.entrySet()) {
 System.out.println(entry.getKey()+"-----"+entry.getValue());
 }
 }

 /**
 * 生成用户示例用户列表
 * @return
 */
 private List<User> generatorUserList() {
 List<User> list = new ArrayList<>();

 User user1 = new User();
 user1.setName("19");
 user1.setAge(18);
 user1.setState(1);
 user1.setCreateTime(new Date());
 list.add(user1);

 User user2 = new User();
 user2.setName("1");
 user2.setAge(22);
 user2.setState(1);
 user2.setCreateTime(new Date());
 list.add(user2);

 User user3 = new User();
 user3.setName("2");
 user3.setAge(15);
 user3.setState(2);
 user3.setCreateTime(new Date());
 list.add(user3);

 User user4 = new User();
 user4.setName("23");
 user4.setAge(15);
 user4.setState(2);
 user4.setCreateTime(new Date());
 list.add(user4);

 User user5 = new User();
 user5.setName("23");
 user5.setAge(18);
 user5.setState(2);
 user5.setCreateTime(new Date());
 list.add(user5);
 return list;
 }







 @Data
 class User{
 private String name;

 private Integer age;

 private Integer state;

 private Date createTime;

 }
}

String API

Mon, 01 Jan 0001 00:00:00 +0000



/**
 * public final class String
 * String 是包装类型，且为final修饰不能被继承
 * 一下提供字符串拼接和字符串反转的方法
 */
public class StringUtils {

 public static void main(String[] args) {
 StringUtils.stringJoin();
 StringUtils.stringReverse();
 }


 public static void stringJoin(){

 //StringBuffer字符串连接 线程安全的
 StringBuffer buffer = new StringBuffer();
 buffer.append("a");
 buffer.append("b");
 buffer.append("c");
 buffer.append("d");
 System.out.println(buffer.toString());

 //StringBuilder字符串连接， 非线程安全的，但是速度快
 StringBuilder builder = new StringBuilder();
 builder.append("a");
 builder.append("b");
 builder.append("c");
 builder.append("d");
 System.out.println(builder.toString());
 }


 //字符串反转
 public static void stringReverse(){
 // StringBuffer reverse
 StringBuffer stringBuffer = new StringBuffer();
 stringBuffer.append("abcdefg");
 System.out.println(stringBuffer.reverse()); // gfedcba

 // StringBuilder reverse
 StringBuilder stringBuilder = new StringBuilder();
 stringBuilder.append("abcdefg");
 System.out.println(stringBuilder.reverse()); // gfedcba
 }
}

TryCache到底怎么返回值

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo;

public class TestTryCatch {
 public static void main(String[] args) {
 System.out.println(getInt1());
 System.out.println(getInt2());
 }

 public static int getInt1() {
 int a = 10;
 try {
 System.out.println(a / 0);
 a = 20;
 } catch (ArithmeticException e) {
 a = 30;
 return a;
 /*
 * return a 在程序执行到这一步的时候，这里不是return a 而是 return 30；这个返回路径就形成了
 * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
 * 再次回到以前的路径,继续走return 30，形成返回路径之后，这里的a就不是a变量了，而是常量30
 */
 } finally {
 a = 40;
 }
 return a;
 }

 public static int getInt2() {
 int a = 10;
 try {
 System.out.println(a / 0);
 a = 20;
 } catch (ArithmeticException e) {
 a = 30;
 return a;
 /*
 * return a 在程序执行到这一步的时候，这里不是return a 而是 return 30；这个返回路径就形成了
 * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
 * 再次回到以前的路径,继续走return 30，形成返回路径之后，这里的a就不是a变量了，而是常量30
 */
 } finally {
 a = 40;
 return a; //如果这样，就又重新形成了一条返回路径，由于只能通过1个return返回，所以这里直接返回40
 }

// return a;
 }
}

Valid参数校验

Mon, 01 Jan 0001 00:00:00 +0000

简单使用

Java API规范(JSR303)定义了Bean校验的标准validation-api，但没有提供实现。hibernate validation是对这个规范的实现，并增加了校验注解如@Email、@Length等。

Spring Validation是对hibernate validation的二次封装，用于支持spring mvc参数自动校验。接下来，我们以spring-boot项目为例，介绍Spring Validation的使用。

引入依赖

如果spring-boot版本小于2.3.x，spring-boot-starter-web会自动传入hibernate-validator依赖。如果spring-boot版本大于2.3.x，则需要手动引入依赖：

<dependency>
 <groupId>org.hibernate</groupId>
 <artifactId>hibernate-validator</artifactId>
 <version>6.0.1.Final</version>
</dependency>

对于web服务来说，为防止非法参数对业务造成影响，在Controller层一定要做参数校验的！大部分情况下，请求参数分为如下两种形式：

POST、PUT请求，使用requestBody传递参数；
GET请求，使用requestParam/PathVariable传递参数。

下面我们简单介绍下requestBody和requestParam/PathVariable的参数校验实战！

requestBody参数校验

POST、PUT请求一般会使用requestBody传递参数，这种情况下，后端使用DTO对象进行接收。只要给DTO对象加上@Validated注解就能实现自动参数校验。比如，有一个保存User的接口，要求userName长度是2-10，account和password字段长度是6-20。

如果校验失败，会抛出MethodArgumentNotValidException异常，Spring默认会将其转为400（Bad Request）请求。

DTO表示数据传输对象（Data Transfer Object），用于服务器和客户端之间交互传输使用的。在spring-web项目中可以表示用于接收请求参数的Bean对象。

在DTO字段上声明约束注解

@Data
public class UserDTO {

 private Long userId;

 @NotNull
 @Length(min = 2, max = 10)
 private String userName;

 @NotNull
 @Length(min = 6, max = 20)
 private String account;

 @NotNull
 @Length(min = 6, max = 20)
 private String password;
}

在方法参数上声明校验注解

ZIPUtils

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.zip;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ZipUtilFileInfo {
 private String name;
 private String url;

 private Boolean Local;
}

package cn.anzhongwei.lean.demo.zip;

import org.apache.commons.lang.ArrayUtils;
import org.apache.pdfbox.io.IOUtils;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.zip.*;

public class ZipUtils2 {
 private static final int BUFFER = 256;

 public static void main(String[] args) throws IOException {
 String hallFilePath = "d:/" + "qwe";
 compress(Paths.get(hallFilePath).toString(), hallFilePath + ".zip");

 List<ZipUtilFileInfo> downFileInfos = new ArrayList<>();
 ZipUtilFileInfo d1 = new ZipUtilFileInfo( "价格导入模板.xlsx", "http://网络地址", false);
 ZipUtilFileInfo d2 = new ZipUtilFileInfo( "订单导入_仓储.xlsx", "http://网络地址", false);
 downFileInfos.add(d1);
 downFileInfos.add(d2);
 File zipfile1 = gerenatorZIPFileFromUrl(downFileInfos, "t1.zip");
 File zipfile2 = gerenatorZIPFileFromUrl(downFileInfos, "t2.zip");
 File zipfile3 = gerenatorZIPFileFromUrl(downFileInfos, "t3.zip");


 List<ZipUtilFileInfo> downFileInfos2 = new ArrayList<>();
 ZipUtilFileInfo dd1 = new ZipUtilFileInfo( zipfile1.getName(), zipfile1.getAbsolutePath(), true);
 ZipUtilFileInfo dd2 = new ZipUtilFileInfo( zipfile2.getName(), zipfile1.getAbsolutePath(), true);
 ZipUtilFileInfo dd3 = new ZipUtilFileInfo( zipfile3.getName(), zipfile1.getAbsolutePath(), true);
 downFileInfos2.add(dd1);
 downFileInfos2.add(dd2);
 downFileInfos2.add(dd3);

 File ff2 = gerenatorZIPFileFromUrl(downFileInfos2, "tt1.zip");

 System.out.println(zipfile1.getAbsolutePath());
 InputStream inputStream = new FileInputStream(ff2);
 File tempFile = new File("C:\\testFile\\");
 if (!tempFile.exists()) {
 tempFile.mkdirs();
 }
 OutputStream os = new FileOutputStream(tempFile.getPath() + File.separator + "shishi.zip");
 byte[] bs = new byte[1024];
 int len;
 while ((len = inputStream.read(bs)) != -1) {
 os.write(bs, 0, len);
 }
 }

 //文件或目录打包成zip
 public static void compress(String fromPath, String toPath) throws IOException {
 File fromFile = new File(fromPath);
 File toFile = new File(toPath);
 if (!fromFile.exists()) {
 throw new RuntimeException(fromPath + "不存在！");
 }
 try (FileOutputStream outputStream = new FileOutputStream(toFile);
 CheckedOutputStream checkedOutputStream = new CheckedOutputStream(outputStream, new CRC32());
 ZipOutputStream zipOutputStream = new ZipOutputStream(checkedOutputStream)) {
 String baseDir = "";
 compress(fromFile, zipOutputStream, baseDir);
 }
 }



 private static void compress(File file, ZipOutputStream zipOut, String baseDir) throws IOException {
 if (file.isDirectory()) {
 compressDirectory(file, zipOut, baseDir);
 } else {
 compressFile(file, zipOut, baseDir);
 }
 }


 private static void compressFile(File file, ZipOutputStream zipOut, String baseDir) throws IOException {
 if (!file.exists()) {
 return;
 }
 try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file))) {
 ZipEntry entry = new ZipEntry(baseDir + file.getName());
 zipOut.putNextEntry(entry);
 int count;
 byte[] data = new byte[BUFFER];
 while ((count = bis.read(data, 0, BUFFER)) != -1) {
 zipOut.write(data, 0, count);
 }
 }
 }



 private static void compressDirectory(File dir, ZipOutputStream zipOut, String baseDir) throws IOException {
 File[] files = dir.listFiles();
 if (files != null && ArrayUtils.isNotEmpty(files)) {
 for (File file : files) {
 compress(file, zipOut, baseDir + dir.getName() + File.separator);
 }
 }
 }

 private static File gerenatorZIPFileFromUrl(List<ZipUtilFileInfo> downFileInfos, String zipFileName) {

 try {
 File zipFile = File.createTempFile(zipFileName, ".zip");
 FileOutputStream f = new FileOutputStream(zipFile);
 CheckedOutputStream csum = new CheckedOutputStream(f, new Adler32());
 ZipOutputStream zos = new ZipOutputStream(csum);
 for (ZipUtilFileInfo downFileInfo : downFileInfos) {
 InputStream inputStream;
 if (Objects.isNull(downFileInfo.getLocal())) {
 throw new RuntimeException("url类型未指定是否本地，请检查代码");
 }
 if (downFileInfo.getLocal()) {
 inputStream = new FileInputStream(downFileInfo.getUrl());
 } else {
 inputStream = getStreamByUrl(downFileInfo.getUrl());
 }
 zos.putNextEntry(new ZipEntry(downFileInfo.getName()));
 int bytesRead = 0;
 // 向压缩文件中输出数据
 while((bytesRead = inputStream.read()) != -1){
 zos.write(bytesRead);
 }
 inputStream.close();
 zos.closeEntry();
 }
 zos.close();
 return zipFile;
 } catch (Exception e) {
 e.printStackTrace();
 }
 return null;
 }


 public static InputStream getStreamByUrl(String strUrl){
 HttpURLConnection conn = null;
 try {
 URL url = new URL(strUrl);
 conn = (HttpURLConnection)url.openConnection();
 conn.setRequestMethod("GET");
 conn.setConnectTimeout(20 * 1000);
 final ByteArrayOutputStream output = new ByteArrayOutputStream();
 IOUtils.copy(conn.getInputStream(),output);
 return new ByteArrayInputStream(output.toByteArray());
 } catch (Exception e) {
 e.printStackTrace();
 }finally {
 try{
 if (conn != null) {
 conn.disconnect();
 }
 }catch (Exception e){
 e.printStackTrace();
 }
 }
 return null;
 }

}

遍历List

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.list.arraylist;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo {
 public static void main(String[] args) {
 Object obj = new Object();
 List<Object> list = new ArrayList<>();

 int objCount = 1000;
 for (int i = 0; i < objCount; i++) {
 list.add(obj);
 }

 int testTimes = 5;
 for (int i = 0; i < testTimes; i++) {
 testFor(list);
 testForEnhanced(list);
 testForEach(list);
 testIterator(list);
 System.out.println("\n");
 }
 System.out.println("---------------------------------------------------------\n");

 List<Object> list2 = new ArrayList<>();
 for (int i = 0; i < objCount; i++) {
 list2.add(obj);
 }

 for (int i = 0; i < testTimes; i++) {
 testFor(list2);
 testForEnhanced(list2);
 testForEach(list2);
 testIterator(list2);
 System.out.println();
 }
 }

 private static void testFor(List<Object> list) {
 long startTime = 0L;
 long endTime = 0L;
 startTime = System.nanoTime();

 for (int i = 0; i < list.size(); i++) {
 Object o = list.get(i);
 }
 endTime = System.nanoTime();
 System.out.println("for所用时间(ns) ：" + (endTime - startTime));
 }

 private static void testForEnhanced(List<Object> list) {
 long startTime = 0L;
 long endTime = 0L;
 startTime = System.nanoTime();

 for (Object o : list) {
 Object value = o;
 }

 endTime = System.nanoTime();
 System.out.println("增强for所用时间(ns) ：" + (endTime - startTime));
 }

 private static void testForEach(List<Object> list) {
 long startTime = 0L;
 long endTime = 0L;
 startTime = System.nanoTime();

 list.forEach(o->{Object obj = o;});

 endTime = System.nanoTime();
 System.out.println("forEach所用时间(ns) ：" + (endTime - startTime));
 }

 private static void testIterator(List<Object> list) {
 long startTime = 0L;
 long endTime = 0L;
 startTime = System.nanoTime();

 Iterator<Object> iterator = list.iterator();
 while (iterator.hasNext()) {
 Object o = iterator.next();
 }
 endTime = System.nanoTime();
 System.out.println("iterator所用时间(ns) ：" + (endTime - startTime));
 }
}

遍历Map

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class MapTest {
 public static void main(String[] args) {
 Map<String, String> map = new HashMap<String, String>();
 map.put("1", "value1");
 map.put("2", "value2");
 map.put("3", "value3");

 //第一种：普遍使用，二次取值
 System.out.println("通过Map.keySet遍历key和value：");
 for (String key : map.keySet()) {
 System.out.println("key= "+ key + " and value= " + map.get(key));
 }

 //第二种
 System.out.println("通过Map.entrySet使用iterator遍历key和value：");
 Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
 while (it.hasNext()) {
 Map.Entry<String, String> entry = it.next();
 System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
 }

 //第三种：推荐，尤其是容量大时
 System.out.println("通过Map.entrySet遍历key和value");
 for (Map.Entry<String, String> entry : map.entrySet()) {
 System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
 }

 //第四种
 System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
 for (String v : map.values()) {
 System.out.println("value= " + v);
 }
 }
}

从mybatis的sql日志自动填充sql占位符

Mon, 01 Jan 0001 00:00:00 +0000

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 从mybatis的sql日志自动填充sql占位符
 */
public class SqlReplaceUtil extends JFrame {

 private static final Pattern HUMP_PATTERN = Pattern.compile("\\?");
 JPanel jp;
 JButton b1;
 JTextArea sqlTextField;
 JTextArea paramTextField;
 JTextArea resultTextField;
 JLabel lb3;
 JLabel lb4;

 SqlReplaceUtil() {
 jp = new JPanel();
 b1 = new JButton("替换");
 sqlTextField = new JTextArea("输入待处理的SQL，比如：insert into test (id,name,age) values (?,?,?)",10,90);
 paramTextField = new JTextArea("输入待处理参数，比如：100(Integer),zhangsan(String),null",10,90);
 resultTextField = new JTextArea(10,90);
 lb3 = new JLabel("结果为：");
 lb4 = new JLabel("");
 b1.addActionListener(new ActionListener() {//响应按钮的事件
 public void actionPerformed(ActionEvent e) {
 try {
 lb4.setText("");
 String sql = sqlTextField.getText();
 String param = paramTextField.getText();
 resultTextField.setText(replaceSql(sql, param));
 } catch (Exception ex) {
 lb4.setText(ex.getMessage());
 }
 }

 });
 jp.add(sqlTextField);
 jp.add(paramTextField);
 jp.add(b1);
 jp.add(resultTextField);
 jp.add(lb4);

 add(jp);
 setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
 setLocationRelativeTo(null);
 setLocation(600, 200);
 setVisible(true);
 pack();
 setSize(1050, 700);
 setLocationRelativeTo(null);
 setVisible(true);
 setResizable(false);
 }

 public static void main(String[] args) {
 SqlReplaceUtil e = new SqlReplaceUtil();
 Container contentPane = e.getContentPane();
 contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));
 }

 private String replaceSql(String sql, String param) {
 String[] split = param.split(",");
 //校验数量
 int paramCount = split.length;
 int matcherCount = 0;
 Matcher matcher = HUMP_PATTERN.matcher(sql);
 while (matcher.find()) {
 matcherCount++;
 }
 if (paramCount != matcherCount) {
 throw new RuntimeException("待替换参数和参数数量不一致");
 }
 //处理参数
 for (int i = 0; i < split.length; i++) {
 split[i] = split[i].trim();
 int index = split[i].lastIndexOf('(');
 if (split[i].equals("null")||index<0) {
 continue;
 }
 split[i] = "'" + split[i].substring(0, index) + "'";
 }
 StringBuffer sb = new StringBuffer();
 Matcher matcher2 = HUMP_PATTERN.matcher(sql);
 int index = 0;
 while (matcher2.find()) {
 matcher2.appendReplacement(sb, split[index]);
 index++;
 }
 matcher2.appendTail(sb);
 return sb.toString();
 }
}

定义一个由builder来构造的实体类

Mon, 01 Jan 0001 00:00:00 +0000

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * description: Java Builder模式练习
 * @version v1.0
 * @author w
 * @date 2021年7月7日上午11:37:49
 **/
@AllArgsConstructor
@Data
@NoArgsConstructor
public class User {
 private String id ;
 private String name ;
 private Integer age ;

 public static Builder builder(){
 return new Builder();
 }

 public static class Builder{
 private String id ;
 private String name ;
 private Integer age ;

 public Builder id(String id) {
 this.id = id ;
 return this;
 }

 public Builder name(String name) {
 this.name = name ;
 return this ;
 }

 public Builder age(Integer age) {
 this.age = age ;
 return this;
 }

 public User build() {
 return new User(this);
 }

 public User build2() {
 return new User(this.id , this.name , this.age);
 }

 }

 public User(Builder builder) {
 this.id = builder.id;
 this.name = builder.name ;
 this.age = builder.age;
 }

}

public class TestBuilder {
 public static void main(String[] args) {
 User user = User.builder().id("1").name("xiaoming").age(18).build();
 System.out.println(user);
 }
}

根据对象层次路径动态获取和设置值

Mon, 01 Jan 0001 00:00:00 +0000

先看一段json

{
 "wmPlans":
 [
 {
 "skuInfos":
 [
 {
 "customerItemNO":"no-03",
 "goCargoId":"go03"
 },
 {
 "customerItemNO":"no-04",
 "goCargoId":"go04",
 "extensionParameter":
 {
 "invNo":"abcd01",
 "bu":"BM"
 }

 }

 ],
 "warehouseType":"wmsHouse1",
 "warehousedocumentType":"wmsDocument1"
 },
 {
 "skuInfos":
 [
 {
 "customerItemNO":"no-03",
 "goCargoId":"go03"
 },
 {
 "customerItemNO":"no-04",
 "goCargoId":"go04"
 }

 ],
 "warehouseType":"wmsHouse2",
 "warehousedocumentType":"wmsDocument2"
 }

 ],
 "goOrder":
 {
 "extionParam":
 {
 "bbb":"ccc"
 },
 "skuInfos":
 [
 {
 "customerItemNO":"no-01",
 "goCargoId":"go01"
 },
 {
 "customerItemNO":"no-02",
 "goCargoId":"go02"
 }

 ],
 "i3":20,
 "mark3":"mark3",
 "consignorCode":"ConsignorCode01"
 }

}

我希望能根据一个路径

基于BigDecimal的高精度数字运算

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.bigdecimal;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 用于高精确处理常用的数学运算
 */
public class ArithmeticUtils {
 public static void main(String[] args) {
 System.out.println("2.5 to "+toCeiling(new BigDecimal(2.5)));
 System.out.println("4 to "+toCeiling(new BigDecimal(4)));
 System.out.println("4.023 to "+toCeiling(new BigDecimal(4.023)));
 System.out.println("0.5 to "+toCeiling(new BigDecimal(0.5)));
 System.out.println("-0.5 to "+toCeiling(new BigDecimal(-0.5)));
 System.out.println("-1.5 to "+toCeiling(new BigDecimal(-1.5)));
 System.out.println(new BigDecimal("1.000").abs());
 System.out.println(new BigDecimal("1").abs());
 BigDecimal b1 = new BigDecimal("5");
 BigDecimal b2 = new BigDecimal("4.000");
 System.out.println(b1.compareTo(b2));

 }
 //默认除法运算精度
 private static final int DEF_DIV_SCALE = 10;

 /**
 * 提供精确的加法运算
 *
 * @param v1 被加数
 * @param v2 加数
 * @return 两个参数的和
 */

 public static double add(double v1, double v2) {
 BigDecimal b1 = new BigDecimal(Double.toString(v1));
 BigDecimal b2 = new BigDecimal(Double.toString(v2));
 return b1.add(b2).doubleValue();
 }

 /**
 * 提供精确的加法运算
 *
 * @param v1 被加数
 * @param v2 加数
 * @return 两个参数的和
 */
 public static BigDecimal add(String v1, String v2) {
 BigDecimal b1 = new BigDecimal(v1);
 BigDecimal b2 = new BigDecimal(v2);
 return b1.add(b2);
 }

 /**
 * 提供精确的加法运算
 *
 * @param v1 被加数
 * @param v2 加数
 * @param scale 保留scale 位小数
 * @return 两个参数的和
 */
 public static String add(String v1, String v2, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException(
 "The scale must be a positive integer or zero");
 }
 BigDecimal b1 = new BigDecimal(v1);
 BigDecimal b2 = new BigDecimal(v2);
 return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
 }

 /**
 * 提供精确的减法运算
 *
 * @param v1 被减数
 * @param v2 减数
 * @return 两个参数的差
 */
 public static double sub(double v1, double v2) {
 BigDecimal b1 = new BigDecimal(Double.toString(v1));
 BigDecimal b2 = new BigDecimal(Double.toString(v2));
 return b1.subtract(b2).doubleValue();
 }

 /**
 * 提供精确的减法运算。
 *
 * @param v1 被减数
 * @param v2 减数
 * @return 两个参数的差
 */
 public static BigDecimal sub(String v1, String v2) {
 BigDecimal b1 = new BigDecimal(v1);
 BigDecimal b2 = new BigDecimal(v2);
 return b1.subtract(b2);
 }

 /**
 * 提供精确的减法运算
 *
 * @param v1 被减数
 * @param v2 减数
 * @param scale 保留scale 位小数
 * @return 两个参数的差
 */
 public static String sub(String v1, String v2, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException(
 "The scale must be a positive integer or zero");
 }
 BigDecimal b1 = new BigDecimal(v1);
 BigDecimal b2 = new BigDecimal(v2);
 return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
 }

 /**
 * 提供精确的乘法运算
 *
 * @param v1 被乘数
 * @param v2 乘数
 * @return 两个参数的积
 */
 public static double mul(double v1, double v2) {
 BigDecimal b1 = new BigDecimal(Double.toString(v1));
 BigDecimal b2 = new BigDecimal(Double.toString(v2));
 return b1.multiply(b2).doubleValue();
 }

 /**
 * 提供精确的乘法运算
 *
 * @param v1 被乘数
 * @param v2 乘数
 * @return 两个参数的积
 */
 public static BigDecimal mul(String v1, String v2) {
 BigDecimal b1 = new BigDecimal(v1);
 BigDecimal b2 = new BigDecimal(v2);
 return b1.multiply(b2);
 }

 /**
 * 提供精确的乘法运算
 *
 * @param v1 被乘数
 * @param v2 乘数
 * @param scale 保留scale 位小数
 * @return 两个参数的积
 */
 public static double mul(double v1, double v2, int scale) {
 BigDecimal b1 = new BigDecimal(Double.toString(v1));
 BigDecimal b2 = new BigDecimal(Double.toString(v2));
 return round(b1.multiply(b2).doubleValue(), scale);
 }

 /**
 * 提供精确的乘法运算
 *
 * @param v1 被乘数
 * @param v2 乘数
 * @param scale 保留scale 位小数
 * @return 两个参数的积
 */
 public static String mul(String v1, String v2, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException(
 "The scale must be a positive integer or zero");
 }
 BigDecimal b1 = new BigDecimal(v1);
 BigDecimal b2 = new BigDecimal(v2);
 return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
 }

 /**
 * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
 * 小数点以后10位，以后的数字四舍五入
 *
 * @param v1 被除数
 * @param v2 除数
 * @return 两个参数的商
 */

 public static double div(double v1, double v2) {
 return div(v1, v2, DEF_DIV_SCALE);
 }

 /**
 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
 * 定精度，以后的数字四舍五入
 *
 * @param v1 被除数
 * @param v2 除数
 * @param scale 表示表示需要精确到小数点以后几位。
 * @return 两个参数的商
 */
 public static double div(double v1, double v2, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException("The scale must be a positive integer or zero");
 }
 BigDecimal b1 = new BigDecimal(Double.toString(v1));
 BigDecimal b2 = new BigDecimal(Double.toString(v2));
 return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
 }

 /**
 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
 * 定精度，以后的数字四舍五入
 *
 * @param v1 被除数
 * @param v2 除数
 * @param scale 表示需要精确到小数点以后几位
 * @return 两个参数的商
 */
 public static String div(String v1, String v2, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException("The scale must be a positive integer or zero");
 }
 BigDecimal b1 = new BigDecimal(v1);
 BigDecimal b2 = new BigDecimal(v1);
 return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
 }

 /**
 * 提供精确的小数位四舍五入处理
 *
 * @param v 需要四舍五入的数字
 * @param scale 小数点后保留几位
 * @return 四舍五入后的结果
 */
 public static double round(double v, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException("The scale must be a positive integer or zero");
 }
 BigDecimal b = new BigDecimal(Double.toString(v));
 return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
 }

 /**
 * 提供精确的小数位四舍五入处理
 *
 * @param v 需要四舍五入的数字
 * @param scale 小数点后保留几位
 * @return 四舍五入后的结果
 */
 public static String round(String v, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException(
 "The scale must be a positive integer or zero");
 }
 BigDecimal b = new BigDecimal(v);
 return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
 }

 /**
 * 取余数
 *
 * @param v1 被除数
 * @param v2 除数
 * @param scale 小数点后保留几位
 * @return 余数
 */
 public static String remainder(String v1, String v2, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException(
 "The scale must be a positive integer or zero");
 }
 BigDecimal b1 = new BigDecimal(v1);
 BigDecimal b2 = new BigDecimal(v2);
 return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
 }

 /**
 * 取余数 BigDecimal
 *
 * @param v1 被除数
 * @param v2 除数
 * @param scale 小数点后保留几位
 * @return 余数
 */
 public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException(
 "The scale must be a positive integer or zero");
 }
 return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
 }

 /**
 * 比较大小
 *
 * @param v1 被比较数
 * @param v2 比较数
 * @return 如果v1 大于v2 则 返回true 否则false
 */
 public static boolean compare(String v1, String v2) {
 BigDecimal b1 = new BigDecimal(v1);
 BigDecimal b2 = new BigDecimal(v2);
 int bj = b1.compareTo(b2);
 boolean res;
 if (bj > 0)
 res = true;
 else
 res = false;
 return res;
 }

 public static BigDecimal toCeiling(BigDecimal val){

// if (val.compareTo(new BigDecimal(1)) >= 0) {
// return val.round(new MathContext(1, RoundingMode.CEILING));
// } else {
 return val.setScale(0, RoundingMode.CEILING);
// }
 }
}

运行结果

基于序列化的深拷贝

Mon, 01 Jan 0001 00:00:00 +0000

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;

import java.io.Serializable;

@AllArgsConstructor
@Data
@ToString
class Car implements Serializable {
 private static final long serialVersionUID = -5713945027627603702L;

 private String brand; // 品牌
 private int maxSpeed; // 最高时速
}

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;

import java.io.Serializable;

@AllArgsConstructor
@Data
@ToString
class Person implements Serializable {
 private static final long serialVersionUID = -9102017020286042305L;

 private String name; // 姓名
 private int age; // 年龄
 private Car car; // 座驾
}


import java.io.*;

/**
 * 浅拷贝只是复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化，这就是浅拷贝（例：assign()）
 *
 * 深拷贝是将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变，这就是深拷贝（例：JSON.parse()和JSON.stringify()，但是此方法无法复制函数类型）
 */
public class CloneUtil {

 public static void main(String[] args) {
 try {
 Person p1 = new Person("郭靖", 33, new Car("Benz", 300));
 Person p2 = CloneUtil.clone(p1); // 深度克隆
 p2.getCar().setBrand("BYD");
 // 修改克隆的Person对象p2关联的汽车对象的品牌属性
 // 原来的Person对象p1关联的汽车不会受到任何影响
 // 因为在克隆Person对象时其关联的汽车对象也被克隆了
 System.out.println(p1);
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 // 私有构造方法
 private CloneUtil() {
 throw new AssertionError();
 }

 /*
 注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，
 可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，
 这种是方案明显优于使用Object类的clone方法克隆对象。
 让问题在编译的时候暴露出来总是好过把问题留到运行时。
 */
 @SuppressWarnings("unchecked")
 public static <T extends Serializable> T clone(T obj) throws Exception {
 ByteArrayOutputStream bout = new ByteArrayOutputStream();
 ObjectOutputStream oos = new ObjectOutputStream(bout);
 oos.writeObject(obj);

 ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
 ObjectInputStream ois = new ObjectInputStream(bin);
 return (T) ois.readObject();

 // 说明：调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义
 // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放
 }
}

时间日期

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.date;


import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Date;

public class DateUtils {
 private static final DateTimeFormatter YEAH_MONTH_DAY = DateTimeFormatter.ofPattern("yyyy-MM-dd");
 private static final DateTimeFormatter YEAH_MONTH_DAY_HOUR_MINUTE_SECOND = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

 public DateUtils() {
 }

 public static void main(String[] args) {

 System.out.println("1. 获取当前日期字符串: " + getNowDateTime());
//
 System.out.println("2.1 获取UTC时间: " + getUTCTime());

 System.out.println("2.2 获取时间戳: " + getTimestamp());
//
 System.out.println("3. 根据字符串日期转LocalDate: " + getString2LocalDate("2019-01-01"));

 System.out.println("4. 根据字符串日期时间转 LocalDateTime: " + getString2FullDate("2019-01-01 00:00:00"));

 System.out.println("5. 根据自定义格式获取当前日期: " + getNowDateByFormatter("yyyy++MM++dd"));

 System.out.println("6. 根据自定义格式获取当前日期时间: " + getNowDateTimeByFormatter("yyyy++MM++dd HH:mm:ss"));

 System.out.printf(
 """
 7. 根据节点获取当前日期时间信息
 %s 年 %s 月 %s 日 星期 %s 是今年的第%s天
 %s时 %s分 %s秒
 %n""", getNowDateNode(DateEnum.YEAR),
 getNowDateNode(DateEnum.MONTH),
 getNowDateNode(DateEnum.DAY),
 getNowDateNode(DateEnum.WEEK),
 getNowDateNode(DateEnum.DAYOFYEAR),
 getNowDateNode(DateEnum.HOUR),
 getNowDateNode(DateEnum.MINUTE),
 getNowDateNode(DateEnum.SECOND)
 );

 System.out.println("8. 一年后的日期时间: " + getPreOrAfterDateTime(DateEnum.YEAR, 1));
 System.out.println("8. 一年前的日期时间: " + getPreOrAfterDateTime(DateEnum.YEAR, -1));

 System.out.println("8. 一小时后的日期时间: " + getPreOrAfterDateTime(DateEnum.HOUR, 1));
 System.out.println("8. 一小时前的日期时间: " + getPreOrAfterDateTime(DateEnum.HOUR, -1));

 System.out.println("9. 比较两个日期时间大小 2019-01-01 00:00:00 & 2019-01-01 00:00:01: " + compareDateTime("2019-01-01 00:00:00", "2019-01-01 00:00:01"));

 System.out.println("10. 判断是否闰年: " + isLeapYear("2024-01-01"));

 System.out.println("11. 两个日期间隔天数: " + getPeridNum("2019-01-01", "2019-01-01", DateEnum.DAY));

 System.out.println("12. 获取当前时区：" + getTimeZone());

 System.out.println("13. 获取America/Los_Angeles时区时间 ZoneId.SHORT_IDS：" + getTimeZoneDateTime("America/Los_Angeles"));
 }



 // 1. 获取当前日期时间字符串
 // 改成LocalDate.now().toString() 获取当前日期字符串
 // 改成LocalTime.now().toString() 获取当前时间字符串
 public static String getNowDateTime() {
 return LocalDateTime.now().format(YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 }

 // 2.1 获得utd时间
 public static String getUTCTime() {
 //Clock类
 return Clock.systemUTC().instant().toString();
 }

 // 2.2 获得时间戳
 public static Long getTimestamp() {
 //Clock类
 return Clock.systemUTC().millis();
 }

 // 3. 根据字符串日期转LocalDate
 public static LocalDate getString2LocalDate(String date) {
 return LocalDate.parse(date, YEAH_MONTH_DAY);
 }

 // 4. 根据字符串日期时间转 LocalDateTime
 public static LocalDateTime getString2FullDate(String date) {
 return LocalDateTime.parse(date, YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 }

 // 5. 根据自定义格式获取当前日期
 public static String getNowDateByFormatter(String formatterPattern) {
 return LocalDate.now().format(DateTimeFormatter.ofPattern(formatterPattern));
 }

 // 6. 根据自定义格式获取当前日期时间
 public static String getNowDateTimeByFormatter(String formatterPattern) {
 return LocalDateTime.now().format(DateTimeFormatter.ofPattern(formatterPattern));
 }

 // 7. 获取当前 节点
 public static Integer getNowDateNode(DateEnum dateEnum) {
 LocalDateTime nowDate = LocalDateTime.now();
 Integer nowNode = null;
 switch (dateEnum) {
 case YEAR:
 nowNode = nowDate.getYear();
 break;
 case MONTH:
 nowNode = nowDate.getMonthValue();
 break;
 case WEEK:
 nowNode = conversionWeek2Num(DateUtils.WeekEnum.valueOf(nowDate.getDayOfWeek().toString()));
 break;
 case DAY:
 nowNode = nowDate.getDayOfMonth();
 break;
 case DAYOFYEAR:
 nowNode = nowDate.getDayOfYear();
 break;
 case HOUR:
 nowNode = nowDate.getHour();
 break;
 case MINUTE:
 nowNode = nowDate.getMinute();
 break;
 case SECOND:
 nowNode = nowDate.getSecond();
 }

 return nowNode;
 }

 // 8. 从当前日期加或减一个 年 月 日 周 时 分 秒 的时间 加就是正数 减就是负数
 // LocalDateTime nowDate = LocalDateTime.now();
 // 改成 LocalDate nowDate = LocalDate.now(); 就是只能获取 年月日周
 // 改成 LocalTime nowDate = LocalTime.now(); 就是只能获取 时 分 秒
 public static String getPreOrAfterDateTime(DateEnum dateEnum, long time) {
 LocalDateTime nowDate = LocalDateTime.now();
 switch (dateEnum) {
 case YEAR:
 // 从api 的角度也可以用 这个api提供的时间单位更多
// nowDate.plus(time, ChronoUnit.YEARS);
// nowDate.minus(time, ChronoUnit.YEARS)
 return nowDate.plusYears(time).format(YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 case MONTH:
 return nowDate.plusMonths(time).format(YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 case WEEK:
 return nowDate.plusWeeks(time).format(YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 case DAY:
 return nowDate.plusDays(time).format(YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 case DAYOFYEAR:
 throw new RuntimeException("不支持的选项");
 case HOUR:
 return nowDate.plusHours(time).format(YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 case MINUTE:
 return nowDate.plusMinutes(time).format(YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 case SECOND:
 return nowDate.plusSeconds(time).format(YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 default:
 throw new RuntimeException("不支持的选项");
 }
 }

 // 9. 比较日期时间 begin 比 end 早 返回true
 // 同理LocalDate比较日期 LocalTime 比较时间
 public static boolean compareDateTime(String begin, String end) {
 LocalDateTime beginDate = LocalDateTime.parse(begin, YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 LocalDateTime endDate = LocalDateTime.parse(end, YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 return beginDate.isBefore(endDate);
 }

 // 10. 判断是否闰年
 public static boolean isLeapYear(String date) {
 return LocalDate.parse(date.trim()).isLeapYear();
 }

 // 11. 获取两个日期之间的间隔 这个函数只能用LocalDate
 public static Integer getPeridNum(String begin, String end, DateEnum dateEnum) {
 switch (dateEnum) {
 case YEAR:
 return Period.between(LocalDate.parse(begin), LocalDate.parse(end)).getYears();
 case MONTH:
 return Period.between(LocalDate.parse(begin), LocalDate.parse(end)).getMonths();
 case WEEK:
 throw new RuntimeException("不支持的参数");
 case DAY:
 return Period.between(LocalDate.parse(begin), LocalDate.parse(end)).getDays();
 default:
 throw new RuntimeException("不支持的参数");
 }
 }

 // 12. 获取当前时区
 public static String getTimeZone() {
 return ZoneId.systemDefault().toString();
 }

 // 13. 获取指定时区时间 ZoneId.SHORT_IDS
 public static String getTimeZoneDateTime(String timeZone) {
 return LocalDateTime.now(ZoneId.of(timeZone)).format(YEAH_MONTH_DAY_HOUR_MINUTE_SECOND);
 }




 public static int conversionWeek2Num(WeekEnum weekEnum) {
 switch (weekEnum) {
 case MONDAY:
 return 1;
 case TUESDAY:
 return 2;
 case WEDNESDAY:
 return 3;
 case THURSDAY:
 return 4;
 case FRIDAY:
 return 5;
 case SATURDAY:
 return 6;
 case SUNDAY:
 return 7;
 default:
 return -1;
 }
 }

 public static enum WeekEnum {
 MONDAY,
 TUESDAY,
 WEDNESDAY,
 THURSDAY,
 FRIDAY,
 SATURDAY,
 SUNDAY;

 private WeekEnum() {
 }
 }

 public static enum DateEnum {
 YEAR,
 MONTH,
 WEEK,
 DAY,
 HOUR,
 MINUTE,
 SECOND,
 DAYOFYEAR;

 private DateEnum() {
 }
 }
}

使用抽象类来实现接口

Mon, 01 Jan 0001 00:00:00 +0000

创建接口类

package cn.anzhongwei.lean.demo.abstractImplementInterface;

import java.math.BigDecimal;

/**
 * 接口中定义3个方法
 */
public interface InterfaceA {
 int a();
 String b();
 BigDecimal c();
}

创建抽象类

package cn.anzhongwei.lean.demo.abstractImplementInterface;

/**
 * 抽象中去实现两个方法，只有c()没有在抽象类中实现，留给最后类去实现c
 *
 */
public abstract class AbstractB implements InterfaceA{
 @Override
 public int a() {
 return 1;
 }

 @Override
 public String b() {
 return "Hello World!";
 }

}

创建实现类

package cn.anzhongwei.lean.demo.abstractImplementInterface;

import java.math.BigDecimal;

/**
 * 由类来实现抽象中未实现得方法， 这样得好处是可以将抽象当成通用得实现，每个最终得实现只去实现差异即可，
 * 既有通用得又有灵活的方法
 */
public class ClassC extends AbstractB{
 @Override
 public BigDecimal c() {
 return new BigDecimal(20);
 }
}

测试类

package cn.anzhongwei.lean.demo.abstractImplementInterface;

public class TestMain {
 public static void main(String[] args) {
 InterfaceA interfaceA1 = new ClassC();
 System.out.println(interfaceA1.a()); // 1
 System.out.println(interfaceA1.b()); // Hello World!
 System.out.println(interfaceA1.c()); // 20


 AbstractB abstractB2 = new ClassC();
 System.out.println(abstractB2.a()); // 1
 System.out.println(abstractB2.b()); // Hello World!
 System.out.println(abstractB2.c()); // 20

 ClassC classc3 = new ClassC();
 System.out.println(classc3.a()); // 1
 System.out.println(classc3.b()); // Hello World!
 System.out.println(classc3.c()); // 20
 }
}

文件拷贝

Mon, 01 Jan 0001 00:00:00 +0000


import java.io.*;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;

public class NIOFileReadAndWrite {
 private String file;

 public String getFile() {
 return file;
 }

 public void setFile(String file) {
 this.file = file;
 }

 public NIOFileReadAndWrite(String file) throws IOException {
 super();
 this.file = file;
 }

 /**
 * NIO读取文件
 * @param allocate
 * @throws IOException
 */
 public void read(int allocate) throws IOException {

 RandomAccessFile access = new RandomAccessFile(this.file, "r");

 //FileInputStream inputStream = new FileInputStream(this.file);
 FileChannel channel = access.getChannel();
 ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);

 CharBuffer charBuffer = CharBuffer.allocate(allocate);
 Charset charset = Charset.forName("GBK");
 CharsetDecoder decoder = charset.newDecoder();
 int length = channel.read(byteBuffer);
 while (length != -1) {
 byteBuffer.flip();
 decoder.decode(byteBuffer, charBuffer, true);
 charBuffer.flip();
 System.out.println(charBuffer.toString());
 // 清空缓存
 byteBuffer.clear();
 charBuffer.clear();
 // 再次读取文本内容
 length = channel.read(byteBuffer);
 }
 channel.close();
 if (access != null) {
 access.close();
 }
 }

 /**
 * NIO写文件
 * @param context
 * @param allocate
 * @param chartName
 * @throws IOException
 */
 public void write(String context, int allocate, String chartName) throws IOException{
 // FileOutputStream outputStream = new FileOutputStream(this.file); //文件内容覆盖模式 --不推荐
 FileOutputStream outputStream = new FileOutputStream(this.file, true); //文件内容追加模式--推荐
 FileChannel channel = outputStream.getChannel();
 ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);
 byteBuffer.put(context.getBytes(chartName));
 byteBuffer.flip();//读取模式转换为写入模式
 channel.write(byteBuffer);
 channel.close();
 if(outputStream != null){
 outputStream.close();
 }
 }

 /**
 * nio事实现文件拷贝
 * @param source
 * @param target
 * @param allocate
 * @throws IOException
 */
 public static void nioCpoy(String source, String target, int allocate) throws IOException{
 ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);
 FileInputStream inputStream = new FileInputStream(source);
 FileChannel inChannel = inputStream.getChannel();

 FileOutputStream outputStream = new FileOutputStream(target);
 FileChannel outChannel = outputStream.getChannel();

 int length = inChannel.read(byteBuffer);
 while(length != -1){
 byteBuffer.flip();//读取模式转换写入模式
 outChannel.write(byteBuffer);
 byteBuffer.clear(); //清空缓存，等待下次写入
 // 再次读取文本内容
 length = inChannel.read(byteBuffer);
 }
 outputStream.close();
 outChannel.close();
 inputStream.close();
 inChannel.close();
 }

 public static void fileChannelCopy(String sfPath, String tfPath) {

 File sf = new File(sfPath);
 File tf = new File(tfPath);
 FileInputStream fi = null;
 FileOutputStream fo = null;
 FileChannel in = null;
 FileChannel out = null;
 try{
 fi = new FileInputStream(sf);
 fo = new FileOutputStream(tf);
 in = fi.getChannel();//得到对应的文件通道
 out = fo.getChannel();//得到对应的文件通道
 in.transferTo(0, in.size(), out);//连接两个通道，并且从in通道读取，然后写入out通道
 }catch (Exception e){
 e.printStackTrace();
 }finally {
 try{
 fi.close();
 in.close();
 fo.close();
 out.close();
 }catch (Exception e){
 e.printStackTrace();
 }
 }
 }


 //IO方法实现文件k拷贝
 private static void traditionalCopy(String sourcePath, String destPath) throws Exception {
 File source = new File(sourcePath);
 File dest = new File(destPath);
 if (!dest.exists()) {
 dest.createNewFile();
 }
 FileInputStream fis = new FileInputStream(source);
 FileOutputStream fos = new FileOutputStream(dest);
 byte[] buf = new byte[1024];
 int len = 0;
 while ((len = fis.read(buf)) != -1) {
 fos.write(buf, 0, len);
 }
 fis.close();
 fos.close();
 }

 public static void main(String[] args) throws Exception{


 long start = System.currentTimeMillis();
 nioCpoy("D:\\迅雷下载\\jdk-21_windows-x64_bin.zip", "D:\\qwe\\jdk-21_windows-x64_bin.zip",10240);
 long end = System.currentTimeMillis();
 System.out.println("用时为：" + (end-start));

 long start2 = System.currentTimeMillis();
 fileChannelCopy("D:\\迅雷下载\\jdk-21_windows-x64_bin.zip", "D:\\qwe\\jdk-21_windows-x64_bin.zip");
 long end2 = System.currentTimeMillis();
 System.out.println("用时为：" + (end2-start2));

 long start3 = System.currentTimeMillis();
 traditionalCopy("D:\\迅雷下载\\jdk-21_windows-x64_bin.zip", "D:\\qwe\\jdk-21_windows-x64_bin.zip");
 long end3 = System.currentTimeMillis();
 System.out.println("用时为：" + (end3-start3));
 }

}

下载图片

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.downfileforweb;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;

@RestController
@ResponseBody
public class DownImgController {

 //http://localhost:8080/ttpng?seriesUniqueCode=1
 @GetMapping(value = "/writeImg1")
 public void writeImg1(HttpServletResponse response) throws IOException {
 //设置响应头信息需要在输出流之前， 就可以触发浏览器下载机制, 注释下列3行或将其写在输出流之后， 都只会在浏览器显示不会触发下载
// response.setHeader("Content-disposition", "attachment;filename=cargoExport.jpg");
// response.setContentType("multipart/form-data");
// response.setCharacterEncoding(StandardCharsets.UTF_8.name());

 URL url = null;
 InputStream is = null;
 ByteArrayOutputStream outStream = null;
 HttpURLConnection httpUrl = null;
 //随便找一张图片
 url = new URL("http://img.ay1.cc/uploads/20221114/9f3e884272b562cf8b27a048c3634621.jpg");
 httpUrl = (HttpURLConnection) url.openConnection();
 httpUrl.connect();
 httpUrl.getInputStream();
 is = httpUrl.getInputStream();
 outStream = new ByteArrayOutputStream();
 //创建一个Buffer字符串
 byte[] buffer = new byte[1024];
 //每次读取的字符串长度，如果为-1，代表全部读取完毕
 int len = 0;
 //使用一个输入流从buffer里把数据读取出来
 while ((len = is.read(buffer)) != -1) {
 //用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
 response.getOutputStream().write(buffer, 0, len);
 }

 response.flushBuffer();
 }


 @GetMapping(value = "/writeImg2", produces = MediaType.IMAGE_JPEG_VALUE)
 public void writeImg2(HttpServletResponse response) throws IOException {
 URL url = null;
 InputStream is = null;
 ByteArrayOutputStream outStream = null;
 HttpURLConnection httpUrl = null;

 url = new URL("http://img.ay1.cc/uploads/20221114/9f3e884272b562cf8b27a048c3634621.jpg");
 httpUrl = (HttpURLConnection) url.openConnection();
 httpUrl.connect();
 httpUrl.getInputStream();
 is = httpUrl.getInputStream();
 outStream = new ByteArrayOutputStream();
 //创建一个Buffer字符串
 byte[] buffer = new byte[1024];
 //每次读取的字符串长度，如果为-1，代表全部读取完毕
 int len = 0;
 //使用一个输入流从buffer里把数据读取出来
 while ((len = is.read(buffer)) != -1) {
 //用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
 outStream.write(buffer, 0, len);
 }
 byte[] temp = outStream.toByteArray();

 response.setHeader("Content-disposition", "attachment;filename=cargoExport.jpg");
 response.setContentType("multipart/form-data");
 response.setCharacterEncoding(StandardCharsets.UTF_8.name());
 response.getOutputStream().write(temp);
 response.flushBuffer();
 }


 public void imgToBase64() {
 URL downUrl = new URL("http://localhost/test.png");
 HttpURLConnection conn = (HttpURLConnection) downUrl.openConnection();
 conn.setRequestMethod("GET");
 conn.setConnectTimeout(5000);
 InputStream inputStream = conn.getInputStream();

 ByteArrayOutputStream data = new ByteArrayOutputStream();
 byte[] by = new byte[1024];
 int len = -1;
 while((len = inputStream.read(by)) != -1){
 data.write(by,0,len);
 }
 inputStream.close();
 Base64.getEncoder().encode(data.toByteArray());
 String imgStr = Base64.getEncoder().encodeToString(data.toByteArray());
 System.out.println(imgStr);
 }
}

原生Java发送Post请求

Mon, 01 Jan 0001 00:00:00 +0000

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class JavaPostJson2 {
 final static String url = "http://localhost:1111/sendData";
 // final static String params = "{\"token\":\"12345\","
 // + "\"appId\":\"20180628173051169c85d965d164ed9ab1281d22ff350ec19\"" 
 // + "\"appName\":\"test33\""
 // + "\"classTopic\":\"112\"" 
 // + "\"eventTag\":\"22\"" 
 // + "\"msg\":{}"
 // + "}";
 final static String params = "{\"token\":\"12345\","
 + "\"appId\":\"20180628173051169c85d965d164ed9ab1281d22ff350ec19\","
 + "\"appName\":\"test33\","
 + "\"classTopic\":\"112\","
 + "\"eventTag\":\"22\""
 + "}";

 public static void main(String[] args) {

 String res = post(url, params);
 System.out.println(res);

 }

 /**
 * 发送HttpPost请求
 * 
 * @param strURL
 * 服务地址
 * @param params
 * json字符串,例如: "{ \"id\":\"12345\" }" ;其中属性名必须带双引号<br/>
 * @return 成功:返回json字符串<br/>
 */
 public static String post(String strURL, String params) {
 System.out.println(strURL);
 System.out.println(params);
 BufferedReader reader = null;
 try {
 URL url = new URL(strURL);// 创建连接
 HttpURLConnection connection = (HttpURLConnection) url.openConnection();
 connection.setDoOutput(true);
 connection.setDoInput(true);
 connection.setUseCaches(false);
 connection.setInstanceFollowRedirects(true);
 connection.setRequestMethod("POST"); // 设置请求方式
 // connection.setRequestProperty("Accept", "application/json"); // 设置接收数据的格式
 connection.setRequestProperty("Content-Type", "application/json"); // 设置发送数据的格式
 connection.connect();
 OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream(), "UTF-8"); // utf-8编码
 out.append(params);
 out.flush();
 out.close();
 // 读取响应
 reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
 String line;
 String res = "";
 while ((line = reader.readLine()) != null) {
 res += line;
 }
 reader.close();

 return res;
 } catch (IOException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }
 return "error"; // 自定义错误信息
 }

}