查看“Java 常用语句”的源代码

=== 表达式 ===
==== 逻辑判断 ====
* ||(|): 逻辑或。前者当得出结果时，不会继续执行后面的表达式。如：(x <= 10 || i++ > 10)
* &&(&): 逻辑与。同上。

==== 可变参数 ====
 fun (String... p1)
 ...
 p1.length > 1
 p1[0]

=== 初始化 ===
==== List ====
 # 不可变
 List<String> l1 = Arrays.asList("ISO8601", "YAML", "YML");
 
 # 不可变, Java 9
 List<String> l1 = List.of("ISO8601", "YAML", "YML");
 
 # 可变
 List<String> l2 = new ArrayList<>(Arrays.asList("ISO8601", "YAML"));
 l2.add("YML");

==== Array ====
 int[] na1 = {1,2,3,4,5};
 na1[0] = 0;

==== Map ====
 # 不可变 map, Java 9 方法，支持最多 10 对键值对
 Map.of(key1, val1, key2, val2);

=== 转换 ===
==== 数值 & 字符串 ====
 // int -> string
 String.valueOf(i)    // 产生一个对象
 // 其它数值类型、字符与字符数组(可以指定局部)同样转换
 "" + i               // 产生两个 String 对象

 // int -> string
 String s = "10";
 Integer.parseInt(s)

==== byte & 字符串 ====
 // byte-> string
 String s1 = new String(b1);

 // string -> byte
 byte[] b1 = s1.getBytes();

==== 数组转为字符串 ====
 int[] a1 = {1,2,3,4,5};
 Arrays.toString(a1);

==== 字符串转换字符 ====
 s.charAt(i)

==== List & Set ====
 List<String> list1 = new ArrayList<>(set1)
 Set<String> set1 = new HashSet<>(list1)

==== List & Array ====
 String[] sarray1 = list1.toArray(new String[list1.size()]);
 // 数据转为 List，如果直接使用 Arrays.asList，会创建一个不可变的 List。可以使用 ArrayList 的构造器创建一个可变的 List。
 List<String> list1 = new ArrayList<>(Arrays.asList(sarray1));

==== Object & String ====
 // Map: Object --> String
 Map<String, Object> m1 = new HashMap<String, Object>();
 Map<String, String> m2 = (Map) m1;
 
 // Object --> Map(String, Object)
 // 通过 gson 转换，val 是一个通过 snakeyaml 读出来的结果
 //import com.google.gson.Gson;
 //import com.google.gson.reflect.TypeToken;
 Gson json = new Gson();
 json.fromJson(json.toJson(val.get(key)), new TypeToken<Map<String, Object>>(){}.getType())
 // 下面的转换方式，当 key 为数值时，Map 中 key 也为数值
 (Map<String, Object>)val.get(key)

==== Object 判断 ====
 <small>public static boolean isnull(Object obj1) {        
     if      (obj1 instanceof String)     { return ((String)     obj1).isEmpty(); }
     else if (obj1 instanceof List)       { return ((List)       obj1).isEmpty(); }
     else if (obj1 instanceof Map)        { return ((Map)        obj1).isEmpty(); }
     else if (obj1 instanceof Properties) { return ((Properties) obj1).isEmpty(); }
     else                                 { return false; }
 }</small>

 <small>public static boolean isnull(Object obj1) {
     String type1 = obj1.getClass().toString();
     type1 = type1.substring(type1.lastIndexOf(".") + 1);
     switch (type1) {
         case "String"     : return ((String)       obj1).isEmpty();
         case "ArrayList"  : return ((ArrayList<?>) obj1).isEmpty();
         case "HashMap"    : return ((HashMap<?, ?>)obj1).isEmpty();
         case "Properties1": return ((Properties)   obj1).isEmpty();
     }
     return false;
 }</small>

==== json 转换 ====
 <small><nowiki># fastjson
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.28</version>
</dependency>

List<Object> l1 = new ArrayList<>();
Map<String, Object> m1 = new LinkedHashMap<>();

m1.put("user", "Adam");
m1.put("val", 3);
l1.add(new JSONObject(m1));</nowiki>

 <nowiki>## 以下是用 gson 转换，但 gson.toJson(val) 是将 val(Map)转换成了 String，输出没问题，但是通过 spring-boot List<Object>返回就会出现 \" 现象。
 <!--gson-->
 <dependency>
     <groupId>com.google.code.gson</groupId>
     <artifactId>gson</artifactId>
     <version>2.8.9</version>
 </dependency>
 
 import com.google.gson.Gson;
 Gson gson = new Gson();
 String json1 = gson.toJson(val);
 
 HashMap<String, ArrayList<String>> val1 = new HashMap<>();
 val1 = gson.fromJson(json1, HashMap.class);
 
 - and -
 HashMap<Integer, ArrayList<String>> val;
 val = new HashMap<Integer, ArrayList<String>>();
 
 -.OR.-
 
 <!-- Json -->
 <dependency>
     <groupId>com.googlecode.json-simple</groupId>
     <artifactId>json-simple</artifactId>
     <version>1.1.1</version>
 </dependency>
 
 import org.json.simple.JSONObject;
 JSONObject jval;
 jval = new JSONObject();
 jval.toJSONString(val)</nowiki></small>

=== 条件 ===
==== 判断一个字符串为空 ====
 null == s || "".equals(s)

==== 比较两个字符串，true=相等 ====
 s.equals(s2)

==== 找出字符串位置，-1=不含 ====
 s.indexOf(s2)
==== 判断 key 是否存在 ====
 map1.containsKey(key1)

==== 获取变量类型 ====
.getClass().toString()

=== 循环 ===
==== list ====
 List<String> l1;
 for (String s1 : l1) {
     System.out.println(s1);
 }

==== map ====
 // Map<String, String> m1 = new LinkedHashMap<>(Map.of("a", "1"));
 // 用 m1 中的 key-value 替换 s1 中的相应的 %key% 变量
 for (String key : m1.keySet()) {
     s1 = s1.replaceAll(String.format("%c%s%c", '%', key, '%'), m1.get(key));
 }
 <small>// 下面是一种不是很好的 lambda 写法
 // Error: 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
 m1.forEach((key, value) -> {
     System.out.println(String.format("key: %s, val: %s", key, value));
 //   s1 = s1.replaceAll(String.format("%c%s%c", '%', key, '%'), value);
 });</small>

==== properties ====
 // Properties tmp = new Properties();
 for (String key : tmp.stringPropertyNames()) {
     System.out.println(key + "=" + tmp.getProperty(key));
 }

==== Arrry ====
 // Map<String, String> m1 = new HashMap<>();
 // String s1 = "a,b,c";
 // String[] a1 = s1.split(",");
 for(int i=0; i<l1.length; i++) {
     m1.put(l1[i], "");
 }
 
 -.OR.-
 
 for(String s1 : l1) m1.put(s1, "");

=== 异常处理 ===
==== 可变长参数 ====
 String fun(String src, String... _sep) {}
对此处的可变参的处理需要考虑没有参数和参数值为 null 的情况。
 sep = (_sep==null || _sep.length < 1) ? "" : _sep[0];
注意：上面处理了没有 _sep，以及为 null 的情况，并没有处理 _sep[0] = "" 的情况（因此 "" 即便给默认值，后面还要是判断为空情况）。或者
 sep = (_sep==null || _sep.length < 1 || _sep[0] = "") ? ",=" : _sep[0];   // sep 至少有一个字符
判断流程：
# fun(src): .length < 1
# fun(src, null):  == null
# fun(src, ""):  [0] == ""

==== substring ====
 // src.substring(0, 10)
 Range [0, 10) out of bounds for length 2
需要判断长度

=== 获取信息 ===
==== 当前执行的类名、方法名 ====
* File  : Thread.currentThread().getStackTrace()[2].getFileName()
* Class : Thread.currentThread().getStackTrace()[2].getClassName()
* Method: Thread.currentThread().getStackTrace()[2].getMethodName()
* Line  : Thread.currentThread().getStackTrace()[2].getLineNumber()

 String log1 = "test logger";
 Logger logger = Logger.getLogger(Thread.currentThread().getStackTrace()[2].getClassName());
 logger.info(log1);
 -->
 2024-03-20 09:25:42,222 INFO [test] test logger

=== 常见问题 ===
==== 同一个对象多次 add ====
添加对象时，添加的是它的引用。所以多次 add，发现多条记录都是最后对象的值。

每次 new 对象再 add，如：
 Map<Integer, ArrayList<String>> val = new HashMap<>();
 List<String> l1 = new ArrayList<>();
 for (i=0;...)
     <b>l1 = new ArrayList<>();</b>
     ...
     val.put(i, l1);

==== HashMap 顺序 ====
如果需要严格按照 put 顺序，可以使用 LinkedHashMap。

[[分类:Develop]]
[[分类:Java]]