java代码小宝书

r囧r小猫 2023-10-02 13:18 19阅读 0赞

#### java代码小宝书 ####

*  String Integer
 *   *  嘟嘟嘟
     *   *  生成随机数/字符串
         *  生成X个随机数
         *  IntStream.range()和IntStream.rangeClosed区别
         *  数字按质数和非质数分区
 *  集合操作
 *   *  List集合
     *   *  retainAll() 方法
         *  removeIf()方法
         *  切分Lists.partition
     *  Map集合
     *   *  过滤指定的key
         *  获取map中的key - value值
         *  putIfAbsent和computeIfAbsent
     *  Set集合
     *   *  交集（intersection）和差集（difference）
 *  Redis
 *   *  Redisson
     *  XX操作
     *   *  getBucket
         *  获取set类型数据
         *  分布式Map

## String Integer ##

### 嘟嘟嘟 ###

#### 生成随机数/字符串 ####

[参考链接][Link 1]  
package org.apache.commons.lang3;  
public class RandomStringUtils \{\}  
比如六位数字验证码  
String code = RandomStringUtils.randomNumeric(6);

#### 生成X个随机数 ####

**boxed()**

//功能是生成100个随机数。数字在0到100之间。
    Random random = new Random();
    IntStream intStream = random.ints(0, 100);                 
    intStream.limit(100).boxed().collect(Collectors.toList());
    //IntStream是存的是int类型的stream,而Steam是一个存了Integer的stream。boxed的作用就是将int类型的stream转成了Integer类型的Stream。
    List<Integer> numbers = Arrays.asList(1, 2, 3, 3, 4, 5);
    IntStream intStream = numbers.stream().mapToInt(i -> i);  //转成IntStream
    Stream<Integer> boxed = intStream.boxed();                //转成Stream<Integer>

所以使用的时候  
所以我们在用到这种原始int值的流,比如下面生成随机数的，得到IntStream在转成集合是不行的。会报错。  
random.ints(0, 100).limit(10).collect(Collectors.toList());

**所以我们一定要把它转成Integer类型，像下面这种使用boxed转成了object类型**

random.ints(0, 100).limit(10).boxed().collect(Collectors.toList());

#### IntStream.range()和IntStream.rangeClosed区别 ####

其实区别就是开区间和闭区间的区别,\[1,10),\[1,20\]

//3.创建数字流
            IntStream.of(1, 2, 3);//返回一个intStream
            IntStream.range(1,20).forEach(i-> System.out.print(i+","));//返回一个1-19的数字流
            System.out.println();
            IntStream.rangeClosed(1,20).forEach(i-> System.out.print(i+","));//返回的一个1-20的数字流
    //结果：
    1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,
    1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,

#### 数字按质数和非质数分区 ####

接受参数 int n，并将前n个自然数分为质数和非质数。

//1 首先，找出能够测试某一个待测数字是否是质数的谓词.也就是判断某数字是否是质数的方法。
    public boolean isPrime(int candidate) {
        
    return IntStream.range(2, candidate)   //产生一个自然数范围，从2开始，直至但不包括待测数
    	.noneMatch(i -> candidate % i == 0);//如果待测数字不能被流中任何数字整除则返回 true
    }
    //1-1上述方法优化
    public boolean isPrime(int candidate) {
        
    int candidateRoot = (int) Math.sqrt((double) candidate); //仅测试小于等于待测数平方根的因子
    return IntStream.rangeClosed(2, candidateRoot)
    .noneMatch(i -> candidate % i == 0);
    }
    
    //2 创建一个包含这n个数的流，用刚刚写的 isPrime 方法作为谓词，再给 partitioningBy 收集器归约
    public Map<Boolean, List<Integer>> partitionPrimes(int n) {
        
    return IntStream.rangeClosed(2, n).boxed()
    	.collect(partitioningBy(candidate -> isPrime(candidate)));
    }

## 集合操作 ##

### List集合 ###

#### retainAll() 方法 ####

Java ArrayList中的方法。  
用于保留 arraylist 中在指定集合中也存在的那些元素，也就是删除指定集合中不存在的那些元素。

> arraylist.retainAll(Collection c);

arraylist: \[Google, Runoob, Taobao\]  
Collection : \[Wiki, Runoob, Google\]  
保留的元素: \[Google, Runoob\]

#### removeIf()方法 ####

removeIf() 方法用于删除所有满足特定条件的数组元素。

> arraylist.removeIf(Predicate filter)

collection.removeIf(
    	person -> person.getAge() >= 30
    );//过滤删除30岁以上的求职者，留下<30的。

#### 切分Lists.partition ####

将如下numList集合按指定长度进行切分，返回新的List<List<??>>集合，如下的：  
List<List> lists=Lists.partition(numList,3);

package test;
    
    import com.google.common.collect.Lists;
    import org.junit.Test;
    import java.util.List;
    
    public class testList {
        
    
       @Test
       public void  test(){
        
           List<Integer> numList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
           List<List<Integer>> lists=Lists.partition(numList,3);
           System.out.println(lists);  //[[1, 2, 3], [4, 5, 6], [7, 8]]
       }
    }

Lists.Partition 在项目中遇到的**坑总结**：  
　　项目中使用 Lists.Partition 批量处理数据，但是最近内存一直 OutOffMemory，GC无法回收。  
　　后来我们对使用过的集合手动 clear，没有测试直接就上线了。尴尬的是内存回收了，但是跑出来的数据出问题了。  
　　最后自己单元测试发现是 List<List> resultPartition = Lists.partition(list, 500) 之后再对 list 进行 clear 操作，resultPartition也会被清空。  
　　回来谷歌才发现它最终会调用 list.subList。subList 执行结果是获取 ArrayList 的一部分，返回的是 ArrayList 的部分视图。  
　　对子集合的操作会反映到原集合， 对原集合的操作也会影响子集合。

[参考链接][Link 2]

### Map集合 ###

#### 过滤指定的key ####

Map<String, Object> extendParam = 
    alertMap.entrySet().stream()
    .filter(map -> "labels".equals(map.getKey()) || "annotations".equals(map.getKey()))
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

上述代码是，获取map中指定的key的map集合。只保留labels和annotations 键的数据，组成新的map。

#### 获取map中的key - value值 ####

JDK1.8中map.forEach方式获取Map中的key,value

map.forEach((k,v)->{
        
     
            });

#### putIfAbsent和computeIfAbsent ####

computeIfAbsent用的较多。  
computeIfAbsent源码：

default V computeIfAbsent(K key,
                Function<? super K, ? extends V> mappingFunction) {
        
            Objects.requireNonNull(mappingFunction);
            V v;
            if ((v = get(key)) == null) {
        
                V newValue;
                if ((newValue = mappingFunction.apply(key)) != null) {
        
                    put(key, newValue);
                    return newValue;
                }
            }
    
            return v;
        }

putIfAbsent源码：

default V putIfAbsent(K key, V value) {
        
            V v = get(key);
            if (v == null) {
        
                v = put(key, value);
            }
    
            return v;
        }

### Set集合 ###

#### 交集（intersection）和差集（difference） ####

intersection()方法用于返回两个或更多集合中都包含的元素，即交集。  
difference()函数用户返回两个集合的差集，即返回的在第一个集合但不在第二个集合中的元素  
用法：

x={
        'a','b','c'}
    y={
        'a','d','e'}
    print(Sets.intersection(x,y));
    //输出
    {
        'a'}
    
    print(x.difference(y));
    //输出
    {
        'b', 'c'}

## Redis ##

回顾一下，众所周知，redis的5种数据类型：  
string 字符串（可以为整形、浮点型和字符串，统称为元素）  
list 列表（实现队列,元素不唯一，先入先出原则）  
set 集合（各不相同的元素）  
hash hash散列值（hash的key必须是唯一的）  
sort set 有序集合

[redis的5种数据类型及操作][redis_5]

### Redisson ###

Jedis 和 Redisson 都是Java中**对Redis操作的封装**。Jedis 只是简单的封装了 Redis 的API库，可以看作是Redis客户端，它的方法和Redis 的命令很类似。**Redisson 不仅封装了 redis ，还封装了对更多数据结构的支持，以及锁等功能**，相比于Jedis 更加大。但Jedis相比于Redisson 更原生一些，更灵活。

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括Bitset, Set, MultiMap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish/Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service。Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。  
依赖以及配置文件等：

<dependency>
                    <groupId>org.redisson</groupId>
                    <artifactId>redisson</artifactId>
                    <version>${redisson.version}</version>
                </dependency>
    
    <redisson.version>3.11.5</redisson.version>
    
    
    
    # 是否开启redis缓存：true开启、false关闭
    spring.redis.cluster.nodes=10.0.0.74:6379
    spring.redis.mode=single
    spring.redis.timeout=300000ms
    spring.redis.lettuce.pool.max-idle=100
    spring.redis.lettuce.pool.max-wait=5000ms
    spring.redis.lettuce.pool.max-active=1000
    spring.redis.cluster.max-redirects=10
    spring.cache.type=redis
    spring.redis.lettuce.pool.min-idle=8
    spring.redis.database=0

示例demo：

//创建配置  
    Config config = new Config();  
      
    //指定编码，默认编码为org.redisson.codec.JsonJacksonCodec   
    config.setCodec(new org.redisson.client.codec.StringCodec());  
      
    //指定使用单节点部署方式  
    config.useSingleServer().setAddress("redis://127.0.0.1:6379");  
      
    config.useSingleServer().setClientName("root");
    config.useSingleServer().setPassword("abcabc");
     
    //创建redisson客户端
    RedissonClient redisson = Redisson.create(config);  
     
    RBucket<String> keyObject = redisson.getBucket("key");  
    keyObject.set("value");  
     
    //关闭RedissonClient  
    redisson.shutdown();

[Redis分布式客户端之Redisson的基本使用][Redis_Redisson]

### XX操作 ###

#### getBucket ####

用法：RedissonClient.getBucket方法  
所在包类org.redisson.api.RedissonClient

package org.redisson.api;
    //引入redissonClient
    @Autowired
    private RedissonClient redissonClient;
    
    //设置缓存数据
    SmsCaptchaVO smsCaptcha = new SmsCaptchaVO();
            smsCaptcha.setCode(code);
            smsCaptcha.setExpireDateTime(LocalDateTime.now().plusMinutes(30));
            smsCaptcha.setResendDateTime(LocalDateTime.now().plusMinutes(1));
            RBucket<String> smsCaptchaBucket = redissonClient.getBucket(getKey(mobile));//设置某key的 RBucket
            smsCaptchaBucket.set(new Gson().toJson(smsCaptcha));//设置对应key的值
    
    //获取缓存数据
    String smsCaptchaKey = getKey(mobile);
            SmsCaptchaVO smsCaptcha = null;
            RBucket<String> smsCaptchaBucket = redissonClient.getBucket(smsCaptchaKey);
            logger.info(smsCaptchaBucket.toString());
            if (smsCaptchaBucket.isExists()) {
        
                // 返回Redis数据
                smsCaptcha = new Gson().fromJson(smsCaptchaBucket.get(), SmsCaptchaVO.class);
            }
    
    
    // 删除Redis 对应 数据 (失效掉)
      redissonClient.getBucket(redisKey).delete();

#### 获取set类型数据 ####

> java中用法：RSet rSet= redissonClient.getSet(key);

![在这里插入图片描述][ff4fb24829de49d4a8605e206e5aef17.png]

//用法举例
    package org.redisson.api;
    
    private String env;
    
    RSet<Object> inCheckTable = redissonClient.getSet(String.format("%s_%s", env, MdConstants.IN_CHECKING_TABLE_SET_KEY));
    // 后续可以按照set集合等操作。例如：inCheckTable .contains(str)

**客户端**：  
添加数据  
sadd key member1 \[member2\]  
获取全部数据  
smembers key  
删除数据  
srem key member1 \[member2\]  
获取集合数据总量  
scard key  
判断集合中是否包含指定数据  
sismember key member  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAVmVnZXRhYmxlX3h1_size_20_color_FFFFFF_t_70_g_se_x_16]  
[set集合获取值][set]

#### 分布式Map ####

> java中用法：RMap<k,v> rMap= redissonClient.getMap(key);//String key

RMap<String, String> configMap = redissonClient.getMap(String.format("%s_%s", env, CONFIG_MAP_KEY));
    String dataSourceName = configMap.get(MdConstants.ConfigKey.DATA_SOURCE_CONFIG_KEY);

[RedissonMap的原理][RedissonMap]

[Link 1]: https://blog.csdn.net/yaomingyang/article/details/79107764
[Link 2]: https://www.cnblogs.com/liang1101/p/13636452.html
[redis_5]: https://blog.csdn.net/living_ren/article/details/79166436
[Redis_Redisson]: https://blog.csdn.net/u010963948/article/details/79240050
[ff4fb24829de49d4a8605e206e5aef17.png]: https://img-blog.csdnimg.cn/ff4fb24829de49d4a8605e206e5aef17.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAVmVnZXRhYmxlX3h1_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/2cc9d30d4d1c43aea35479610735d252.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAVmVnZXRhYmxlX3h1,size_20,color_FFFFFF,t_70,g_se,x_16
[set]: https://blog.csdn.net/weixin_42522400/article/details/113317317
[RedissonMap]: https://blog.csdn.net/kq1983/article/details/105220922