JAVA与PHP差异

1.数据类型
八种基本数据类型：整数byte、整数short、整数int、整数long、浮点float、浮点double、布尔boolean、字符char
引用数据类型：类class 接口interface 数组[] 

byte a = 100; 
short s = 1000; 
int a = 100000; 
long a = 100000L; 
float f1 = 234.5f;
double d1 = 123.4;
boolean yes = true;
boolean no = false;
char c='c'; 
public class ClassName{}
public interface InterfaceName{}
dataType[] arrayRefVar  或者  arrayRefVar = new dataType[arraySize];

2.强制类型转换
类型 变量名 = (类型)值;

3.包装数据类型
自带缓存：Boolean(boolean value)、Character(char value)、
自带缓存：Byte(byte value)、Short(short value)、Integer(int value)、Long(long value)、
没有缓存：Float(float value)、Double(double value)

申明：
包装类型 变量名 = new 包装类型(值);
包装类型 变量名 = 变量名.valueOf(值);

方法：
手动装箱：包装类型.valueOf(值)
手动拆箱：变量名.类型Value()

缓存：
启动缓存：包装类型.valueOf(值)
没有缓存：new 包装类型(值)

4.入口函数
class main{
    public static void main(String args[]){
        /......
    }
}

5.分隔符
() {} [] ; , . 
JAVA 中 . 用于将包的名称与子包以及类的名称分隔开，也可以用于将变量或方法与引用变量分隔开

6.变量
数据类型 变量名;
数据类型 变量名 = 值;

7.循环语句
JAV foreach 版本
for(类型 变量名 : 数组){
    //循环体
}

8.函数的概念
修饰符 返回值类型 函数名([参数类型1 参数名1,参数类型2 参数名2....]){
    执行语句...
    return  返回值;    //返回值的类型必须与返回值类型一致
}

8.1 函数的修饰符 abstract、final、 static、synchronized

9.类class
public class ClassName{} //基础类
public final class ClassName{} //不能被继承
abstract class ClassName{} //抽象类
public interface InterfaceName{}  //接口

9.1 类的修饰符 default、private、protected、public 

9.2 类变量的修饰符
静态变量修饰符 static
静态初始化器 static{} ==》构造函数
最终常量 final
易失变量 volatile

9.3 类方法修改饰
抽象方法 abstract
静态方法 static
最终方法 final
本地方法 native
多线程同步方法 synchronized

9.4 类的构造函数
构造函数的名称和包含他的类的名称相同，并在语法上和方法类似.

9.5 类的析构函数
protected void finalize(){}

10.包(命名空间)
package xxx.xxx.xxx;

11.引入外部文件
单独引用：import packageName.className;
包引用：import packageName.*;

12.方法异常throws
class Demo{
    static void one throws IllegalAccessException{
        System.out.println("one");
        throw new IllegalAccessException("Demo");
    }
    public static void main(String args[]){
        try{
            one();
        }catch(IllegalAccessException e){
            System.out.println("CAUGHT " +e);
        }
    }
}

13.泛型(容器)
List<代表泛型的变量> 变量名 = new ArrayList<>();
ArrayList<代表泛型的变量> 变量名 = new ArrayList<>();
Map<代表泛型的变量,代表泛型的变量> 变量名 = new HashMap<>();
Set<代表泛型的变量,代表泛型的变量> 变量名 = new HashSet<>();
Hashtable<代表泛型的变量,代表泛型的变量> 变量名 = new Hashtable<>();
TreeMap<代表泛型的变量,代表泛型的变量> 变量名 = new TreeMap<>();
TreeSet<代表泛型的变量> 变量名 = new TreeSet<>();
Collection<代表泛型的变量> 变量名 = new Vector<>();
Collection<代表泛型的变量> 变量名 = new ArrayList<>();
Collection<代表泛型的变量> 变量名 = new HashSet<>();
Collection<代表泛型的变量> 变量名 = new TreeSet<>();
Vector<代表泛型的变量> 变量名 = new Vector<>();

13.1 泛型类
修饰符 class 类名<代表泛型的变量> { }

13.2 泛型方法
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

13.3 泛型接口
修饰符 interface接口名<代表泛型的变量> {  }

13.4 代表泛型的变量：
E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的 java 类型

13.5 泛型?通配符高级使用
泛型的上限：类型名称 <? extends 类 > 对象名称 ，只能接收该类型及其子类
泛型的下限：类型名称 <? super 类 > 对象名称，只能接收该类型及其父类型

比如：现已知Object类，Animal类，Dog类，Cat类，其中Animal是Dog，Cat的父类

class Animal{}//父类
class Dog extends Animal{}//子类
class Cat extends Animal{}//子类

ArrayList<? extends Animal> list = new ArrayList<Object>(); //报错
ArrayList<? extends Animal> list2 = new ArrayList<Animal>(); //V
ArrayList<? extends Animal> list3 = new ArrayList<Dog>(); //V
ArrayList<? extends Animal> list4 = new ArrayList<Cat>(); //V

ArrayList<? super Animal> list5 = new ArrayList<Object>(); //V
ArrayList<? super Animal> list6 = new ArrayList<Animal>(); //V
ArrayList<? super Animal> list7 = new ArrayList<Dog>(); //报错
ArrayList<? super Animal> list8 = new ArrayList<Cat>(); //报错

函数字符串与数组相互转换：

函数字符串与数组相互转换：
数组合并成字符串： implode()  ===》 join
字符串分割为数组： explode()  ===》 split  

List<String> stringList = Arrays.stream(abc.split(",")).filter(StringUtils::isNotEmpty).map(String::new).collect(Collectors.toList());
List<Long> stringList = Arrays.stream(abc.split(",")).filter(StringUtils::isNotEmpty).map(Long::parseLong).collect(Collectors.toList());

String[] split = goodsTakeDownDto.getGoodsIds().split(",");
List<String> idList = Arrays.asList(split);    

List<Integer> integerList = new ArrayList<>();
integerList.add(1);
integerList.add(2);
integerList.add(3);
StringUtils.join(integerList, "-");

String[] strings = {"11","22","33","44","55"};
String.join("-",strings);

JSON字符串转对象
Object 对象 = JSONObject.parse(JSON字符串);

Object转JSON字符串
String JSON字符串  = JSONObject.toJSONString(对象);  //import com.alibaba.fastjson.JSONObject;

String转JSON
String JSON字符串  = JSON.toJSONString(对象);    //import com.alibaba.fastjson.JSON;

数组对象转JSON
List<Object> LIST变量 = JSONArray.toJSONString(对象);  //import com.alibaba.fastjson.JSONArray;

JSON转LIST对象
List<Object> LIST变量 = JSONArray.parseArray("JSON字符串", Object.class);  //import com.alibaba.fastjson.JSONArray;

JSON转MAP对象
Map MAP变量= JSON.parseObject("JSON字符串", Map.class);  //com.alibaba.fastjson.JSON;

数组操作
array_column(二维数组,null,"xxx") ==》 二维数组.stream().collect(Collectors.toMap(ShopGoodsSkuDto::getXXX, Function.identity()));
array_column(二维数组,"yyy","xxx") ==》二维数组.stream().collect(Collectors.toMap(ShopGoodsSkuDto::getXXX, ShopGoodsSkuDto::getYYY));
array_column(二维数组,"yyy")  ==》二维数组.stream().map(x -> x.getXXX).collect(Collectors.toList());  
array_column(二维数组,"yyy")  ==》二维数组.stream().map(x::getXXX).collect(Collectors.toList());

in_array(查找内容,数组) ==》 Arrays.asList(2, 3, 4, 5).contains(查找内容)

@Data
class XXX{
     @JSONField(name = "start_time")   //下划线转驼峰
     @JsonProperty("start_time")  //驼峰转下划线
     private Integer startTime;
}