在项目中很多时候我们会遇到 byte[] 和 int 之间的相互转换问题，使用 ByteBuffer 可以很优雅的解决这个问题。

可以设置大端模式 ByteOrder.BIG_ENDIAN 和小端模式 ByteOrder LITTLE_ENDIAN:

例如数据为十六进制： 00 00 0x01 0x32 转换为 byte[] 数组为 byte[0] = 0, byte[1] = 0, byte[2] = 1, byte[3] = 50。

这种情况下可以使用大端模式转换，如果是十六进制：0x32 0x01 00 00 则可以使用小端模式转换。

阅读更多

概述

本篇文章是出于对我的《Android内部分享》系列文章和视频中涉及到的Java知识， 考虑到很多朋友初次接触 Android 可能遇到的最大的困扰是 Java 的语法，面对很多视频和文章中的示例，无法理解语法规则何谈去理解 Android 开发，所以我特意做了这篇文章，希望能带你入坑，毕竟只是一篇文章，入坑后得靠自己去多看书，多练习，多思考。

C 和 Java

为什么说 Java 之前要提到 C 语言呢？我考虑的是很多语言其实都是 类C 语言，也就是说大多数语言的语法基础和 C 语言几乎一致，而且 C 语言是高校必学课程，从这一点入手可以事半功倍。

先来看一段 C 语言代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include <stdio.h>

void testFunction(int);

int main(int argc, char const *argv[])
{
    int a = 1;
    testFunction(a);
}

void testFunction(int arg){
    printf("test : %d", arg);
}

这是一个很简单的 C 语言代码，里面定义了变量和函数，接下来我们用 Java 实现同样的功能，大家来对比一下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class TestJava1 {

    public static void main(String[] args){
        int a = 1;
        TestJava1 testJava1 = new TestJava1();
        testJava1.testFunction(a);
    }

    private void testFunction(int arg){
        System.out.println(String.format("test:%d", arg));
    }
}

可以发现有很多不一样的地方，但是其中也蕴含着很多一致的地方，我们对比一下来加深语法层面上的理解：

阅读更多

前言

在 Java 中 int 占 4 个字节， short 占 2 个字节， byte 占 1 个字节，有时候我们需要将 int 转换为 byte 就需要舍弃一些高位或者低位数据。

转换

比如有两个变量：

1
2
3
4
5
6
7

int i = 5;
int j = 0xff24;
int k = -4;
int m = -400;
System.out.println(Integer.toBinaryString(i));
System.out.println(Integer.toBinaryString(j));
System.out.println(Integer.toBinaryString(k));

二进制补码表示:

1
2
3
4
5
6
7
8

0000 0000 0000 0000 0000 0000 0000 0101 （5的补码）
0000 0000 0000 0000 1111 1111 0010 0100 （0xff24的补码）

0000 0000 0000 0000 0000 0000 0000 0100 （-4 的 绝对值）
1111 1111 1111 1111 1111 1111 1111 1100 （-4 的 补码）

0000 0000 0000 0000 0000 0001 1001 0000 （-400 的 绝对值）
1111 1111 1111 1111 1111 1110 0111 0000 （-400 的 补码）

阅读更多

前言

最近在做一个串口相关的项目，里面频繁使用了对字节数组的处理，所以需要使用 ByteBuffer 来处理，于是就对这方面知识做一个简单的梳理和记录。

NIO

Java NIO 是 java 1.4 之后出的一套 IO 接口 NIO 中的 N 可以理解为 Non-blocking，不单纯是 New。

NIO 的特性 / NIO 与 IO 区别：

• IO 是面向流的，NIO 是面向缓冲区的
• IO 流是阻塞的，NIO 流是不阻塞的
• NIO 有选择器，而 IO 没有

阅读更多

前言

最近想做一个小项目，遇到了后台开发问题，从Python、Go、Nodejs、Java、Kotlin中我对比选择了一下，最后还是决定使用自己最熟悉的Java开发，后来又想了一下，既然现在Android开发都是用Kotlin了，而且Kotlin语法这么灵活简介，为何不用Kotlin结合Gradle构建来搭建一个SpringBoot工程呢，整个过程也是本人在逐渐摸索，中间可能会遇到很多障碍和问题，但是没关系，俗话说开弓没有回头箭，因为我已经决定开始了。

阅读更多

参考链接：

《Spring MVC 学习指南（第二版）》

Spring MVC 是 Spring 框架中用于Web应用快速开发的一个模块。Spring框架是一个开源框架，源码下载地址:

1

git clone git@github.com:spring-projects/spring-framework.git

控制反转（IOC）

DI和IOC是差不多的概念，一个重要特征是接口依赖，是把对象关系推迟到运行时去确定。Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

IoC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是 松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

阅读更多

参考链接：

• [1] . 《Java Servlet 技术简介》
• [2] . 《SpringMVC架构浅析》
• [3] . 《Spring MVC 学习指南（第二版）》

距上一次接触JavaWeb已经快6年时间了，最近因工作原因需要学习Web开发知识，这里做一个简单的记录。所以本文适合对JavaWeb开发有一定了解和基础的人群，达到快速拾起并上手的目的。

开发工具：IntelliJ IDEA 构建工具：Maven

创建工程

File -> New -> Project -> Java -> Java Web

创建JavaWeb工程

工程目录结构：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

TestWeb
│  TestWeb.iml
│
├─.idea
│  │  encodings.xml
│  │  misc.xml
│  │  modules.xml
│  │  workspace.xml
│  │
│  └─artifacts
│          TestWeb_war_exploded.xml
│
├─out
│  └─artifacts
│      └─TestWeb_war_exploded
│          │  index.jsp
│          │
│          └─WEB-INF
│                  web.xml
│
├─src
└─web
    │  index.jsp
    │
    └─WEB-INF
        │  web.xml
        │
        ├─classes
        └─lib

阅读更多

参考链接：

• [1] . 《深入理解Java泛型》
• [2] . 《Kotlin 泛型》
• [3] . 《Kotlin中文文档》
• [4] . 《无界通配符》
• [5] . 《Kotin实战》泛型章节
• [6] . 《Effective Java》泛型章节

什么是泛型

泛型的目的是让我们写一套代码可以支持不同的数据类型,下面我们实现一个简单的集合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class MyList{

    private int size;
    private Object[] elements = new Object[10];
    
    public void add(Object item) {
    	elements[size++]=item;
    }
    
    public Object get(int index) {
    	return elements[index];
    }
}

我们实现的集合可以添加任意类型的数据（因为Java中Object是所有类的超类）

1
2
3
4
5

MyList myList = new MyList();
myList.add("A");
myList.add(1);
System.out.println(myList.get(0));
System.out.println((String)myList.get(1));

但是这样的代码有着很大的缺陷，因为需要类型的强制转换，这种转换错误是在编译期间发现不了的，在Java 1.5之前是没有泛型的，就是这样做的。泛型同样可以实现这个需求，但是通过面向对象的多态特性避免了类型强转，而且在编译期间就能发现类型问题。

阅读更多

非常抱歉，尚未完成， 敬请期待…… 行为型模式 迭代子模式 责任链模式 命令模式 备忘录模式 状态模式 访问者模式 中介者模式 解释器模式

阅读更多

结构型模式 桥接模式 将抽象和实现耦合，使得两者可以独立的变化。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 interface Implementor{ void doSomething(); void doAnything(); } class ConcreteImplementor1 implements Implementor{ public void doSomething(){ //具体业务处理 } public void doAnything(){ //具体业务处理 } } abstract class Abstraction{ private Implementor imp; public Abstraction(Implementor _imp){ imp = _imp; } //自身的行为和属性 public void request(){ imp.

阅读更多

总体来说设计模式分为三大类：创建型模式、结构型模式、行为型模式。

创建型模式

简单工厂模式

工厂类是整个模式的关键。它包含必要的判断逻辑，能够根据外界给定的信息知道创建那个类的实例，外部无需了解该对象是如何被创建和组织的。有利于软件体系结构化。由于工厂类集中了所有实例的创建逻辑，简单工厂模式的缺点也体现在工厂类上。

1
2
3
4
5
6
7

//Factory类

if( arg == "A" ){
	return new FrescoLoader();
}else if( arg == "B" ){
	return new GlideLoader();
}

可以明显的看到简单工程模式违反了开放-封闭原则（OCP）

阅读更多

Java中的强、软、弱、虚引用

在JDK中我们可以看到有一个java.lang.ref的包，这个包中就是Java中实现强、软、弱、虚引用的包，如下：

Java中的软引、弱、虚引用

阅读更多