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

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

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

=== 初始化 ===
==== List ====
 # <b>Arrays.asList</b>
 List<String> ISO8601 = Arrays.asList("ISO8601", "YAML", "YML");
 # <b>List.of (JDK9)</b>
 List<String> ISO8601 = List.of("ISO8601", "YAML", "YML");
 # List<String> ISO8601 = new ArrayList<>(Arrays.asList("ISO8601", "YAML", "YML"));  # 可以 add

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

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

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

==== 字符串转换成整数 ====
 String s = "10";
 Integer.parseInt(s)

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

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

==== List & 数组 ====
 String[] sarray1 = list1.toArray(new String[list1.size()]);
 // 数据转为 List，如果直接使用 Arrays.asList，会创建一个不可变的 List。可以使用 ArrayList 的构造器创建一个可变的 List。
 List<String> list1 = new ArrayList<>(Arrays.asList(sarray1));
 
==== json 转换 ====
 # fastjson
 <nowiki><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>

 ## 以下是用 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)

==== 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>

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

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

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

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

=== 循环 ===
==== list ====
 List<String> list1;
 for (String i : list1) {
     System.out.println(list1.get(i));
 }

==== map ====
 Map<String, String> m1;
 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));
 }

=== 获取信息 ===
==== 当前执行的类名、方法名 ====
* 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]]