java随记

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

        HashMap<String,String> map = new HashMap<String,String>();
        map.put("apple", "苹果"); // 向列表中添加数据
        map.put("computer", "计算机"); // 向列表中添加数据
        map.put("book", "图书"); // 向列表中添加数据
        String key = "book";
        boolean contains = map.containsKey(key);
        if (contains) {
            System.out.println("在Map集合中包含键名" + key);
        } else {
            System.out.println("在Map集合中不包含键名" + key);
        }

    }
}

private static void AppServer_NewMessageReceived(WebSocketSession session, string value)
        {
            if (string.IsNullOrEmpty(value))
             {
                return;
             }
            value = HttpUtility.UrlDecode(value);                    
            SuperSocketTemp<string> model = JsonConvert.DeserializeObject<SuperSocketTemp<string>>(value);            
               //具体业务...
        }
        就是这段代码在测试环境抛错，说起来全是泪啊。这段代码的具体业务场景是Websocket即时通讯接收来自客户端的消息，
        消息以json字符串的形式传输。首先判断是否空字符串，
        如果不是，为了防止乱码进行Url解码，然后反序列化消息解析成需要的数据格式，最后执行具体的业务操作。
        测试环境抛的错是万恶的“未将对象引用到对象的实例”，很简单就可以定位到问题的所在——反序列化失败了，只要在序列
        化之后执行具体业务逻辑之前加上非空判断就可以解决掉这个问题。这也怪自己思维还不够严密，没有养成防御性编码的习惯。
         private static void AppServer_NewMessageReceived(WebSocketSession session, string value)
        {
            if (string.IsNullOrEmpty(value))
             {
                return;
             }
            value = HttpUtility.UrlDecode(value);                    
            SuperSocketTemp<string> model = JsonConvert.DeserializeObject<SuperSocketTemp<string>>(value);
            if(model==null)
            {
                return;
            }   
               //具体业务...
        }
        通过日志分析反序列失败的原因，日志中记录的消息是空白的，但是代码中明明有string.IsNullOrEmpty(value)的判断，
        为啥还会出现空的情况呢？仔细一看，原来是多个连续的空格，吐血。于是乎立马把string.IsNullOrEmpty(value)改为
        string.IsNullOrWhiteSpace(value),当value是多个连续的空格时，直接返回，不会继续往下执行。
        private static void AppServer_NewMessageReceived(WebSocketSession session, string value)
        {
            if (string.IsNullOrWhiteSpace(value))
             {
                return;
             }
            value = HttpUtility.UrlDecode(value);                    
            SuperSocketTemp<string> model = JsonConvert.DeserializeObject<SuperSocketTemp<string>>(value);
            if(model==null)
            {
                return;
            }   
               //具体业务...
        }
        我们都知道，string.IsNullOrEmpty方法是判断字符串是否为：null或者string.Empty；string.IsNullOrWhiteSpace方法
        是判断null或者所有空白字符，功能相当于string.IsNullOrEmpty和str.Trim().Length总和。那么具体方法内部是怎么实
        现的呢？我们可以通过ILSpy反编译窥探一番。
        string.IsNullOrEmpty源码分析
        // string
/// <summary>Indicates whether the specified string is null or an <see cref="F:System.String.Empty" /> string.</summary>
/// <param name="value">The string to test. </param>
/// <returns>true if the <paramref name="value" /> parameter is null or an empty string (""); otherwise, false.</returns>
[__DynamicallyInvokable]
public static bool IsNullOrEmpty(string value)
{
    return value == null || value.Length == 0;
}
string.IsNullOrEmpty实现很简单，无非就是判断传入的字符串参数，当是null或者空字符串string.Empty就返回true;否则返回false。
string.IsNullOrWhiteSpace源码分析
// string
/// <summary>Indicates whether a specified string is null, empty, or consists only of white-space characters.</summary>
/// <param name="value">The string to test.</param>
/// <returns>true if the <paramref name="value" /> parameter is null or <see cref="F:System.String.Empty" />, or if <paramref name="value" /> consists exclusively of white-space characters. </returns>
[__DynamicallyInvokable]
public static bool IsNullOrWhiteSpace(string value)
{
    if (value == null)
    {
        return true;
    }
    for (int i = 0; i < value.Length; i++)
    {
        if (!char.IsWhiteSpace(value[i]))
        {
            return false;
        }
    }
    return true;
}
string.IsNullOrWhiteSpace的实现就稍微复杂一些，首先当传入的字符串参数为null时肯定返回true;如果不是就开始遍历字符串，取出字符执行char.IsWhiteSpace(value[i])方法，如果char.IsWhiteSpace(value[i])方法返回false,
就终止遍历，返回fasle;否则返回true。所以char.IsWhiteSpace方法应该判断的是传入的字符是否为空字符，是空字符返回true,不是返回false。我们可以进入char.IsWhiteSpace方法看一下具体实现：
// char
/// <summary>Indicates whether the specified Unicode character is categorized as white space.</summary>
/// <param name="c">The Unicode character to evaluate. </param>
/// <returns>true if <paramref name="c" /> is white space; otherwise, false.</returns>
[__DynamicallyInvokable]
public static bool IsWhiteSpace(char c)
{
    if (char.IsLatin1(c))
    {
        return char.IsWhiteSpaceLatin1(c);
    }
    return CharUnicodeInfo.IsWhiteSpace(c);
}
可以发现方法内部判断了char.IsLatin1(c)，符合的话执行char.IsWhiteSpaceLatin1(c),看不明白，继续往下走。

List<List<Integer>> lists=Lists.partition(numList,3);

package test;
 
import com.google.common.collect.Lists;
import org.junit.Test;
 
import java.util.List;
 
/**
 * Created by Administrator on 2018/10/28/028.
 */
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]]
 
    }
 
}

（1、.next()方法的作用：指针指向下一条记录，有记录（有值）返回true并把记录内容存入到对应的对象中，
也就是obj.next()的obj中。如果没有返回false。

（2、.next()方法的应用：一般和ResultSet对象和while循环一起使用，去迭代结果集，并在循环中调用
getXXX(intfieldIndex)/getXXX(String columnName)方法获取字段值。

过程：ResultSet对象具有指向其当前数据行的指针。开始，指针被置于第一行。.next()方法将指针移动
到下一行，然后while循环迭代遍历ResultSet对象。

while (obj.next()) {

}

光标移动到下一行数据，有值（数据）返回true并迭代遍历，没有返回false退出循环。

if (Objects.requireNonNull(Utils.StringToTimestamp(business.getBiTime())).before(beforeTimestamp)) {//判断对象是否为空
                business.setCcSync(Const.Sync.N);
            } else {
                business.setCcSync(Const.Sync.Y);
            }

public final class Optional<T>

import java.util.Optional;
 
public class Java8Tester {
   public static void main(String args[]){
   
      Java8Tester java8Tester = new Java8Tester();
      Integer value1 = null;
      Integer value2 = new Integer(10);
        
      // Optional.ofNullable - 允许传递为 null 参数
      Optional<Integer> a = Optional.ofNullable(value1);
        
      // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
      Optional<Integer> b = Optional.of(value2);
      System.out.println(java8Tester.sum(a,b));
   }
    
   public Integer sum(Optional<Integer> a, Optional<Integer> b){
    
      // Optional.isPresent - 判断值是否存在
        
      System.out.println("第一个参数值存在: " + a.isPresent());
      System.out.println("第二个参数值存在: " + b.isPresent());
        
      // Optional.orElse - 如果值存在，返回它，否则返回默认值
      Integer value1 = a.orElse(new Integer(0));
        
      //Optional.get - 获取值，值需要存在
      Integer value2 = b.get();
      return value1 + value2;
   }
}

public class Test{
public static void main(String args[]){
                Integer x =Integer.valueOf(9);
                Double c = Double.valueOf(5);
                Float a = Float.valueOf("80");              

                Integer b = Integer.valueOf("444",16);   // 使用 16 进制

                System.out.println(x);//9
                System.out.println(c);//5.0
                System.out.println(a);//80.0
                System.out.println(b);1092
        }
}

Optional<T> findFirst();  
  
Optional<T> findAny();

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;

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

        List<String> strs = Arrays.asList("d", "b", "a", "c", "a");
        Optional<String> min = strs.stream().min(Comparator.comparing(Function.identity()));
        Optional<String> max = strs.stream().max((o1, o2) -> o1.compareTo(o2));
        System.out.println(String.format("min:%s; max:%s", min.get(), max.get()));// min:a; max:d

        Optional<String> aa = strs.stream().filter(str -> !str.equals("a")).findFirst();
        Optional<String> bb = strs.stream().filter(str -> !str.equals("a")).findAny();
//
        Optional<String> aa1 = strs.parallelStream().filter(str -> !str.equals("a")).findFirst();
        Optional<String> bb1 = strs.parallelStream().filter(str -> !str.equals("a")).findAny();
//
        System.out.println(aa.get() + "===" + bb.get());// d===d
        System.out.println(aa1.get() + "===" + bb1.get());//d===b
    }
}