Java常见应用

小咪咪 2023-08-17 16:01 45阅读 0赞

**目录**

Bean 为什么需要一个空参的构造器呢？

后端组成树结构

NIO

缓冲区(buffer)的使用

Arrays方法的巧用

Iterator的使用

泛型方法和类型通配符的使用

JVM 相关

长连接和短连接概念

Spring 的声明式事务

--------------------

# Bean 为什么需要一个空参的构造器呢？ #

*JavaBean*中必须要写一个空参的构造器，因为在通过反射创建对象时，*Class.newInstance()*方法调用的是空参的构造器

反射中的*setAccessible*实际上*setAccessible*是启用和禁用访问安全检查的开关,并不是为*true*就能访问为*false*就不能访问。此对象的*accessible*标志设置为指示的布尔值。值为 *true* 则指示反射的对象在使用时应该取消 *Java* 语言访问检查。值为 *false* 则指示反射的对象应该实施 Java 语言访问检查。由于*JDK*的安全检查耗时较多.所以通过*setAccessible(true)*的方式关闭安全检查就可以达到提升反射速度的目的使用了*method.setAccessible(true)*后 性能有了20倍的提升。

BigDecimal n1 = new BigDecimal("0");
    BigDecimal n2 = new BigDecimal("2");
    n1.add(n2);
    System.out.println(n1);----输出0

这里*n1*并不会加上*n2*的值，应该使用n1=n1.add(n2)

# **后端组成树结构** #

// 生成permission树状结构
    @ResponseBody
    @RequestMapping("/get/permission/tree")
    public ResultVO<PermissionDO> toPermissionPage() {
    	List<PermissionDO> permissions = databaseProviderRemoteService.getAllPermissions().getData();
    	// 生成一个根节点
    	PermissionDO root = null;
    
    	// 创建一个Map保存id-PermissionDO，方法后面用pid去获取
    	Map<Integer, PermissionDO> permissionMap = new HashMap<>();
    
    	// 遍历list找出根节点
    	for (PermissionDO permissionDO : permissions) {
    		// 获取id，并将id和permissionDO存入到map中
    		Integer id = permissionDO.getId();
    		permissionMap.put(id, permissionDO);
    		// 获取pid
    		Integer pid = permissionDO.getPid();
    		if (pid == null) {
    			root = permissionDO;
    		}
    	}
    
    	for (PermissionDO permissionDO : permissions) {
    		// 我们先找出pid不为Null的节点
    		Integer pid = permissionDO.getPid();
    		if (pid != null) {
    			// 通过pid对应的id我们找到它的父节点
    			PermissionDO parent = permissionMap.get(pid);
    			parent.getChildren().add(permissionDO);
    		}
    	}
    
    	return new ResultVO<PermissionDO>(ResultVO.SUCCESS, ResultVO.NO_MSG, root);
    }

# **NIO** #

三大组件：*chanel*、*buffer*、*selector*

![format_png][]

![format_png 1][]

![format_png 2][]

//FileChannel和buffer的简单使用
     RandomAccessFile accessFile = null;
     try {
         accessFile = new RandomAccessFile("test.txt", "rw");
         FileChannel channel = accessFile.getChannel();
         ByteBuffer buffer = ByteBuffer.allocate(1024);
         int bytesRead;
         while ((bytesRead = channel.read(buffer)) != -1) {
             buffer.flip();
             while (buffer.hasRemaining()) {
                 System.out.print((char) buffer.get());
             }
             buffer.compact();
         }
     } finally {
         accessFile.close();
     }

# **缓冲区(buffer)的使用** #

*buffer*：缓冲区，实际上是一个容器、连续数组。*Channel*提供从文件、网络读取数据的渠道，但是读写的数据都必须经过*buffer*。

可以把*buffer*简单地理解为一组基本数据类型的元素列表，它通过几个变量来保存这个数据的当前位置状态：*capacity、position、limit、mark。*

<table> 
 <thead> 
  <tr> 
   <th>索引</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>capacity</td> 
   <td>缓冲区数组的总长度</td> 
  </tr> 
  <tr> 
   <td>position</td> 
   <td>下一个要操作的数据元素的位置</td> 
  </tr> 
  <tr> 
   <td>limit</td> 
   <td>缓冲区数组中不可操作的下一个元素的位置：limit&lt;=capacity</td> 
  </tr> 
  <tr> 
   <td>mark</td> 
   <td>用于记录当前position的前一个位置或者默认是-1</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>作用</th> 
   <th>相关方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>分配空间</td> 
   <td>ByteBuffer buffer = ByteBuffer.allocate(1024);</td> 
  </tr> 
  <tr> 
   <td>写入数据到buffer中</td> 
   <td>int bytesRead = channel.read(buffer)</td> 
  </tr> 
  <tr> 
   <td>判断buffer中有数据</td> 
   <td>boolean b=buffer.hasRemaining()</td> 
  </tr> 
  <tr> 
   <td>从Buffer中读取数据</td> 
   <td>buffer.get()</td> 
  </tr> 
  <tr> 
   <td>开始时</td> 
   <td>buffer.flip()</td> 
  </tr> 
  <tr> 
   <td>结束时</td> 
   <td>buffer.compact()</td> 
  </tr> 
 </tbody> 
</table>

# **Arrays方法的巧用** #

1.  将数组转换成*List*：`List<String> list = Arrays.asList(arr.split(","));`
2.  数组根据*ASCII*码排序:`Arrays.sort(arrayToSort, String.CASE_INSENSITIVE_ORDER);`
3.  *List*转换*SQL in*后面的条件:
    
        String idList = Arrays.asList(list).toString().replace("[[", "(").replace("]]", ")");
        String idList = Arrays.toString(list.toArray()).replace("[", "(").replace("]", ")");

# **Iterator的使用** #

【---list---】
     List<Integer> list = new ArrayList<>();
     //遍历
     while (iterator.hasNext()) {
         System.out.print(iterator.next() + " ");
     }
     //删除
     while (iterator.hasNext()) {
         iterator.remove();
     }
     
     【---map---】
     Map<Integer, String> map = new HashMap<>();
     Iterator<Integer> it = map.keySet().iterator();
     while(it.hasNext()) {
         Integer key = it.next();
         System.out.println(key+"->"+map.get(key));
     }

# 泛型方法和类型通配符的使用 #

泛型方法：*K,V*表示具体的一个*java*类型

public class Test8<K,V> {
        
        public static void main(String[] args) {
            Test8<String, String> test8 = new Test8<>();
            Map<String, String> map = new HashMap<>();
            map.put("k1", "v1");
            map.put("k2", "v2");
            test8.test(map);
        }
        
        public void test(Map<K, V> map) {
            map.forEach((k,v) -> System.out.print("K:"+k+" V:"+v+"\n"));
        }
    }

类型通配的使用：？ 表示不确定的 *java* 类型

public class Test9 {
        
        public static void main(String[] args) {
            Test9 test9 = new Test9();
            Map<String, String> map = new HashMap<>();
            map.put("k1", "v1");
            map.put("k2", "v2");
            test9.test(map);
        }
        
        public void test(Map<?, ?> map) {
            map.forEach((k,v) -> System.out.print("K:"+k+" V:"+v+"\n"));
        }
    }

# `JVM 相关` #

**内存分配：*****`java -jar -Xms128m -Xmx256m xx.war`***

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Xms</td> 
   <td>指设定程序启动时占用内存大小</td> 
  </tr> 
  <tr> 
   <td>Xmx</td> 
   <td>是指设定程序运行期间最大可占用的内存大小</td> 
  </tr> 
  <tr> 
   <td>Xss</td> 
   <td>指设定每个线程的堆栈大小</td> 
  </tr> 
 </tbody> 
</table>

以上三个参数的设置都是默认以Byte为单位的，也可以在数字后面添加\[k/K\]或者\[m/M\]来表示KB或者MB。

# 长连接和短连接概念 #

长连接：长时间保持客户端与服务端的连接状态。默认超时时间8小时

短连接：数据传输完毕立即断开，每次连接只完成一项业务的发送

# Spring 的声明式事务 #

@Transactional(readOnly = false, rollbackFor = Exception.class,
        propagation = Propagation.REQUIRES_NEW)

[format_png]: /images/20230810/1a8e4bef86384fb8a79724ae0e7952c0.png
[format_png 1]: /images/20230810/4cfc91933d2f424cb3fb1dddc4c31ce0.png
[format_png 2]: /images/20230810/7ec6debee97440278af8bbdff4bc29c7.png