精华内容
下载资源
问答
  • 本文实例讲述了Java封装数组之动态数组实现方法。分享给大家供大家参考,具体如下:前言:在此之前,我们封装的数组属于静态数组,也即数组空间固定长度,对于固定长度的数组当元素超过容量时会报数组空间不足。为了...

    本文实例讲述了Java封装数组之动态数组实现方法。分享给大家供大家参考,具体如下:

    前言:在此之前,我们封装的数组属于静态数组,也即数组空间固定长度,对于固定长度的数组当元素超过容量时会报数组空间不足。为了能更好的使用数组,我们来实现一个可以自动扩充容量的数组。

    实现思路:

    1.当数组容量达到事先定义值时创建一个空间是data数组两倍的newData数组(扩容);

    2.把data数组中的元素全部赋值到newData数组中;

    3.把data数组重新执行newData数组。

    一、定义核心扩容方法

    // 数组扩容

    private void resize(int newCapacity){

    E[] newData = (E[]) new Object[newCapacity];

    for (int i = 0; i < size; i++) {

    newData[i] = data[i];

    }

    data = newData;

    }

    二、改进之前的数组添加元素方法(数组空间不够时自动扩容 --原理空间的2倍)

    //在第index个位置插入一个新元素

    public void add(int index, E e) {

    //(1)判断当前需要插入值的位置是否合理,合理则转入(3),否则抛出位置不合法异常

    if (index < 0 || index > size)

    throw new IllegalArgumentException("您选择的位置不合法");

    //(2)先判断当前数组容量是否已满,满则进行容量扩充

    if (size == data.length)

    resize(data.length * 2);

    //将index位置之后的元素往后依次移动一位

    for (int i = size - 1; i >= index; i--) {

    //(3)将index之后的元素依次往后移动一位,然后将新元素插入到index位置

    data[i + 1] = data[i];

    }

    data[index] = e;

    //(4)维护size值

    size++;

    }

    三、改进之前的数组删除元素方法(数组空间空闲太大就会缩容(原来空间的1/2))

    //从数组中删除index位置的元素,返回删除的元素

    public E remove(int index) {

    //1.判断索引的选择是否合法

    if (index < 0 || index > size)

    throw new IllegalArgumentException("您选择的位置不合法");

    //2.先存储需要删除的索引对应的值

    E ret = data[index];

    //将索引为index之后(index)的元素依次向前移动

    for (int i = index + 1; i < size; i++) {

    //3.执行删除--实质为索引为index之后(index)的元素依次向前移动,将元素覆盖

    data[i - 1] = data[i];

    }

    //4.维护size变量

    size--;

    // loitering objects != memory leak 手动释放内存空间

    data[size] = null;

    if (size == data.length / 2) {

    resize(data.length / 2);

    }

    //5.返回被删除的元素

    return ret;

    }

    通过以上,我们就可以实现一个动态的数组。

    测试一下改进后的代码:

    1.测试addLast()

    DynamicArray arr=new DynamicArray(10);

    for (int i = 0; i < 10; i++) {

    arr.addLast(i);

    }

    System.out.println("添加数组元素:");

    System.out.println(arr);

    结果为:

    e9e6318bce773658a8eb3e6e752aa48d.png

    2.测试add(int index,E e)方法

    arr.add(1, 100);

    System.out.println("在数组指定索引位置插入元素e:");

    System.out.println(arr);

    结果:

    e92c29a305ea6e61ced24b7c6f4ceaaa.png

    现在数组已经从刚才定义的容量为10个变为了容量为20个,数组中元素为11个,为此实现了数组扩容。

    3.测试removeLast方法

    System.out.println("删除数组最后一个元素:");

    arr.removeLast();

    System.out.println(arr);

    结果为:

    b2919d07d5dfa44e249eafe467656c4c.png

    此时我们可以看出,删除一个元素之后,数组容量又从新变为了10个。

    本节所有代码:

    /**

    * 3.动态数组

    * 数组容量可变

    */

    public class DynamicArray {

    //使用private 的目的是防止用户从外界修改,造成数据不一致

    private E[] data;

    private int size;//数组中元素个数

    //构造函数,传入数组的容量capacity构造Array函数

    public DynamicArray(int capacity) {

    data = (E[]) new Object[capacity];//泛型不能直接实例化

    size = 0;

    }

    //无参构造函数,默认数组的容量capacity=10

    public DynamicArray() {

    this(10);

    }

    //获取数组中元素个数

    public int getSize() {

    return size;

    }

    //获取数组的容量

    public int getCapacity() {

    return data.length;

    }

    //获取数据是否为空

    public boolean iEmpty() {

    return size == 0;

    }

    //向所有元素后添加元素

    public void addLast(E e) {

    add(size, e);//size表示此时的最后一个元素

    }

    //在所有元素之前添加一个新元素

    public void addFirst(E e) {

    add(0, e);//0表示第一个位置

    }

    //在第index个位置插入一个新元素

    public void add(int index, E e) {

    //(1)判断当前需要插入值的位置是否合理,合理则转入(3),否则抛出位置不合法异常

    if (index < 0 || index > size)

    throw new IllegalArgumentException("您选择的位置不合法");

    //(2)先判断当前数组容量是否已满,满则进行容量扩充

    if (size == data.length)

    resize(data.length * 2);

    //将index位置之后的元素往后依次移动一位

    for (int i = size - 1; i >= index; i--) {

    //(3)将index之后的元素依次往后移动一位,然后将新元素插入到index位置

    data[i + 1] = data[i];

    }

    data[index] = e;

    //(4)维护size值

    size++;

    }

    //获取index索引位置的元素

    public E get(int index) {

    //(1)判断当前需要插入值的位置是否合理,合理则转入(2),否则抛出位置不合法异常

    if (index < 0 || index > size)

    throw new IllegalArgumentException("您选择的位置不合法");

    //(2)返回索引index对应的值

    return data[index];

    }

    //获取最后一个元素

    public E getLast() {

    return get(size - 1);

    }

    //获取第一个元素

    public E getFirst() {

    return get(0);

    }

    //修改index索引位置的元素为e

    void set(int index, E e) {

    //(1)判断当前需要插入值的位置是否合理,合理则转入(2),否则抛出位置不合法异常

    if (index < 0 || index > size)

    throw new IllegalArgumentException("您选择的位置不合法");

    //(2)修改索引index对应的值

    data[index] = e;

    }

    //查找数组中是否包含元素e

    public boolean contains(E e) {

    for (int i = 0; i < size; i++) {

    if (data[i] == e)

    return true;

    }

    return false;

    }

    //查找数组中元素e所在的索引(只是一个),如果不存在元素e,则返回-1;

    public int find(E e) {

    for (int i = 0; i < size; i++) {

    if (data[i] == e)

    return i;

    }

    return -1;

    }

    //从数组中删除index位置的元素,返回删除的元素

    public E remove(int index) {

    //1.判断索引的选择是否合法

    if (index < 0 || index > size)

    throw new IllegalArgumentException("您选择的位置不合法");

    //2.先存储需要删除的索引对应的值

    E ret = data[index];

    //将索引为index之后(index)的元素依次向前移动

    for (int i = index + 1; i < size; i++) {

    //3.执行删除--实质为索引为index之后(index)的元素依次向前移动,将元素覆盖

    data[i - 1] = data[i];

    }

    //4.维护size变量

    size--;

    // loitering objects != memory leak 手动释放内存空间

    data[size] = null;

    //缩容操作

    if (size == data.length / 2 && data.length != 0) {

    resize(data.length / 4);

    }

    //5.返回被删除的元素

    return ret;

    }

    //从数组中删除第一个元素,返回删除的元素

    public E removeFirst() {

    return remove(0);

    }

    //从数组中删除最后一个元素,返回删除的元素

    public E removeLast() {

    return remove(size - 1);

    }

    //从数组中删除元素(只是删除一个)

    public void removeElement(E e) {

    int index = find(e);

    if (index != -1)

    remove(index);

    }

    // 数组扩容方法

    private void resize(int newCapacity) {

    E[] newData = (E[]) new Object[newCapacity];

    for (int i = 0; i < size; i++) {

    newData[i] = data[i];

    }

    data = newData;

    }

    @Override

    public String toString() {

    StringBuilder res = new StringBuilder();

    res.append(String.format("Array:size=%d, capacity=%d\n", size, data.length));

    res.append('[');

    for (int i = 0; i < size; i++) {

    res.append(data[i]);

    if (i != size - 1) {

    res.append(",");

    }

    }

    res.append(']');

    return res.toString();

    }

    }

    测试代码:

    public class test {

    public static void main(String[] args) {

    DynamicArray arr=new DynamicArray(10);

    for (int i = 0; i < 10; i++) {

    arr.addLast(i);

    }

    System.out.println("添加数组元素:");

    System.out.println(arr);

    arr.add(1, 100);

    System.out.println("在数组指定索引位置插入元素e:");

    System.out.println(arr);

    System.out.println("删除数组最后一个元素:");

    arr.removeLast();

    System.out.println(arr);

    }

    }

    希望本文所述对大家java程序设计有所帮助。

    展开全文
  • * * Json java * string java.lang.String * number java.lang.Number * true|false java.lang.Boolean * null null * array java.util.List * object java.util.Map*/@SuppressWarnings({"rawtypes", "unchecked"}...

    /*** Copyright (c) 2011-2015, James Zhan 詹波 (jfinal@126.com).

    *

    * Licensed under the Apache License, Version 2.0 (the "License");

    * you may not use this file except in compliance with the License.

    * You may obtain a copy of the License at

    *

    *http://www.apache.org/licenses/LICENSE-2.0*

    * Unless required by applicable law or agreed to in writing, software

    * distributed under the License is distributed on an "AS IS" BASIS,

    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    * See the License for the specific language governing permissions and

    * limitations under the License.*/

    packagecom.jfinal.kit;importjava.lang.reflect.Method;importjava.text.SimpleDateFormat;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.Iterator;importjava.util.List;importjava.util.Map;importcom.jfinal.plugin.activerecord.Model;importcom.jfinal.plugin.activerecord.Record;/*** Convert object to json string.

    *

    * Json java

    * string java.lang.String

    * number java.lang.Number

    * true|false java.lang.Boolean

    * null null

    * array java.util.List

    * object java.util.Map*/@SuppressWarnings({"rawtypes", "unchecked"})public classJsonKit {private static int convertDepth = 8;private static String timestampPattern = "yyyy-MM-dd HH:mm:ss";private static String datePattern = "yyyy-MM-dd";public static void setConvertDepth(intconvertDepth) {if (convertDepth < 2)throw new IllegalArgumentException("convert depth can not less than 2.");

    JsonKit.convertDepth=convertDepth;

    }public static voidsetTimestampPattern(String timestampPattern) {if (timestampPattern == null || "".equals(timestampPattern.trim()))throw new IllegalArgumentException("timestampPattern can not be blank.");

    JsonKit.timestampPattern=timestampPattern;

    }public static voidsetDatePattern(String datePattern) {if (datePattern == null || "".equals(datePattern.trim()))throw new IllegalArgumentException("datePattern can not be blank.");

    JsonKit.datePattern=datePattern;

    }private static String mapToJson(Map map, intdepth) {if(map == null)return "null";

    StringBuilder sb= newStringBuilder();boolean first = true;

    Iterator iter=map.entrySet().iterator();

    sb.append(‘{‘);while(iter.hasNext()){if(first)

    first= false;elsesb.append(‘,‘);

    Map.Entry entry=(Map.Entry)iter.next();

    toKeyValue(String.valueOf(entry.getKey()),entry.getValue(), sb, depth);

    }

    sb.append(‘}‘);returnsb.toString();

    }private static String toKeyValue(String key, Object value, StringBuilder sb, intdepth){

    sb.append(‘\"‘);if(key == null)

    sb.append("null");elseescape(key, sb);

    sb.append(‘\"‘).append(‘:‘);

    sb.append(toJson(value, depth));returnsb.toString();

    }private static String listToJson(List list, intdepth) {if(list == null)return "null";boolean first = true;

    StringBuilder sb= newStringBuilder();

    Iterator iter=list.iterator();

    sb.append(‘[‘);while(iter.hasNext()){if(first)

    first= false;elsesb.append(‘,‘);

    Object value=iter.next();if(value == null){

    sb.append("null");continue;

    }

    sb.append(toJson(value, depth));

    }

    sb.append(‘]‘);returnsb.toString();

    }/*** Escape quotes, \, /, \r, \n, \b, \f, \t and other control characters (U+0000 through U+001F).*/

    private staticString escape(String s) {if(s == null)return null;

    StringBuilder sb= newStringBuilder();

    escape(s, sb);returnsb.toString();

    }private static voidescape(String s, StringBuilder sb) {for(int i=0; i

    sb.append("\\\"");break;case ‘\\‘:

    sb.append("\\\\");break;case ‘\b‘:

    sb.append("\\b");break;case ‘\f‘:

    sb.append("\\f");break;case ‘\n‘:

    sb.append("\\n");break;case ‘\r‘:

    sb.append("\\r");break;case ‘\t‘:

    sb.append("\\t");break;case ‘/‘:

    sb.append("\\/");break;default:if((ch >= ‘\u0000‘ && ch <= ‘\u001F‘) || (ch >= ‘\u007F‘ && ch <= ‘\u009F‘) || (ch >= ‘\u2000‘ && ch <= ‘\u20FF‘)) {

    String str=Integer.toHexString(ch);

    sb.append("\\u");for(int k=0; k<4-str.length(); k++) {

    sb.append(‘0‘);

    }

    sb.append(str.toUpperCase());

    }else{

    sb.append(ch);

    }

    }

    }

    }public staticString toJson(Object value) {returntoJson(value, convertDepth);

    }public static String toJson(Object value, intdepth) {if(value == null || (depth--) < 0)return "null";if(value instanceofString)return "\"" + escape((String)value) + "\"";if(value instanceofDouble){if(((Double)value).isInfinite() ||((Double)value).isNaN())return "null";else

    returnvalue.toString();

    }if(value instanceofFloat){if(((Float)value).isInfinite() ||((Float)value).isNaN())return "null";else

    returnvalue.toString();

    }if(value instanceofNumber)returnvalue.toString();if(value instanceofBoolean)returnvalue.toString();if (value instanceofjava.util.Date) {if (value instanceofjava.sql.Timestamp)return "\"" + new SimpleDateFormat(timestampPattern).format(value) + "\"";if (value instanceofjava.sql.Time)return "\"" + value.toString() + "\"";return "\"" + new SimpleDateFormat(datePattern).format(value) + "\"";

    }if(value instanceofMap) {returnmapToJson((Map)value, depth);

    }if(value instanceofList) {returnlistToJson((List)value, depth);

    }

    String result=otherToJson(value, depth);if (result != null)returnresult;//类型无法处理时当作字符串处理,否则ajax调用返回时js无法解析//return value.toString();

    return "\"" + escape(value.toString()) + "\"";

    }private static String otherToJson(Object value, intdepth) {if (value instanceofCharacter) {return "\"" + escape(value.toString()) + "\"";

    }if (value instanceofModel) {

    Map map=com.jfinal.plugin.activerecord.CPI.getAttrs((Model)value);returnmapToJson(map, depth);

    }if (value instanceofRecord) {

    Map map=((Record)value).getColumns();returnmapToJson(map, depth);

    }if (value instanceofObject[]) {

    Object[] arr=(Object[])value;

    List list= newArrayList(arr.length);for (int i=0; i

    list.add(arr[i]);returnlistToJson(list, depth);

    }if (value instanceofEnum) {return "\"" + ((Enum)value).toString() + "\"";

    }returnbeanToJson(value, depth);

    }private static String beanToJson(Object model, intdepth) {

    Map map= newHashMap();

    Method[] methods=model.getClass().getMethods();for(Method m : methods) {

    String methodName=m.getName();int indexOfGet = methodName.indexOf("get");if (indexOfGet == 0 && methodName.length() > 3) { //Only getter

    String attrName = methodName.substring(3);if (!attrName.equals("Class")) { //Ignore Object.getClass()

    Class>[] types =m.getParameterTypes();if (types.length == 0) {try{

    Object value=m.invoke(model);

    map.put(StrKit.firstCharToLowerCase(attrName), value);

    }catch(Exception e) {throw newRuntimeException(e.getMessage(), e);

    }

    }

    }

    }else{int indexOfIs = methodName.indexOf("is");if (indexOfIs == 0 && methodName.length() > 2) {

    String attrName= methodName.substring(2);

    Class>[] types =m.getParameterTypes();if (types.length == 0) {try{

    Object value=m.invoke(model);

    map.put(StrKit.firstCharToLowerCase(attrName), value);

    }catch(Exception e) {throw newRuntimeException(e.getMessage(), e);

    }

    }

    }

    }

    }returnmapToJson(map, depth);

    }/*** TODO

    public static Map jsonToMap(String jsonStr) {

    throw new RuntimeException("not finished");

    }*/}

    展开全文
  • 众所周知,java对常见的原始数据类型都提供了对应的封装类型,增加一些常用的特性(如 计算hash值、比较相等、类型转换等),以扩展他们对数据处理的能力,使得他们更好地适应面向对象编程的各种场景。今天,我们首先...

    众所周知,java对常见的原始数据类型都提供了对应的封装类型,增加一些常用的特性(如 计算hash值、比较相等、类型转换等),以扩展他们对数据处理的能力,使得他们更好地适应面向对象编程的各种场景。今天,我们首先来学习 boolean 布尔型对应的封装类型。

    1. 定义

    首先来看看定义(下图),可以看到,Boolean 实现了序列化和比较接口,说明一个 Boolean 对象是可以序列化的;是可以比较大小的;另外,注意 final 修饰符,Boolean 不可被继承。

    6c16bfe1e353172e6cd48afff40e3951.png

    2. 属性

    下图是 Boolean 类型的重要属性字段:

    764e654025da93200aac4ba00bad6d62.png

    2.1. 枚举静态引用

    我们知道,原始 boolean 类型只存在两个值:true 和 false。既然只有两种值,那么封装类就干脆定义两个静态的引用,分别保持对两个值对象实例的引用,它们会在类加载的时候被初始化。

    2.2. 值

    注意 value 字段的 final 修饰符,说明一个 Boolean 类型对象的值是不允许改变的。

    2.3. 类型引用

    我们知道,虚拟机在类加载的时候,会为每个类创建一个 Class 对象,用于在运行时表示这个类的类型信息(比如:类名、全类名、有哪些修饰符、有哪些方法和属性、有哪些注解等),那么原始数据类型也不例外,上图 TYPE 就是保持对这个 Class 对象的引用。

    3. 构造方法

    Boolean 有两个构造方法,分别接收原始数据类型 boolean 值和字符串 “true”或者“false”(忽略大小写)如果传的字符串为 null,那么自动认为该对象值为 false。

    ac62b0f38abbe9b190afc4e283f0823f.png

    上图中红框中注释说明了,不建议使用构造方法,而建议使用静态工厂 valueOf(boolean) 方法,下面是 valueOf 方法代码。可以看出,静态工厂方法会直接返回类属性 TRUE 或 FALSE 引用的静态对象实例,他们在类加载的时候已经实例化。这样就不需要再分配内存空间了,节省了时间和空间。

    a0399695872b7cd621ded55e8f327c3e.png

    4. 普通方法

    boolean

    将此 Boolean对象的值作为布尔原始值返回。

    static int

    compare(boolean x, boolean y)

    比较两个 boolean值。

    int

    将此 Boolean实例与另一个实例进行比较。

    boolean

    返回 true当且仅当参数不是 null ,并且是一个 Boolean对象,表示与此对象相同的 boolean值。

    static boolean

    返回 true当且仅当由参数命名的系统属性存在且等于字符串 "true" 。

    int

    返回此 Boolean对象的哈希码。

    static int

    hashCode(boolean value)

    返回一个boolean值的哈希码; 兼容Boolean.hashCode() 。

    static boolean

    logicalAnd(boolean a, boolean b)

    返回将逻辑AND运算符应用于指定的 boolean操作数的结果。

    static boolean

    logicalOr(boolean a, boolean b)

    返回将逻辑OR运算符应用于指定的 boolean操作数的结果。

    static boolean

    logicalXor(boolean a, boolean b)

    返回将逻辑XOR运算符应用于指定的 boolean操作数的结果。

    static boolean

    返回一个 String此布尔值的 String对象。

    static String

    toString(boolean b)

    返回一个 String指定布尔值的 String对象。

    valueOf(boolean b)

    返回一个 Boolean指定的 boolean值的 Boolean实例。

    返回一个 Boolean ,其值由指定的字符串表示。

    4.1. compare 和 compareTo

    前面定义中我们已知,Boolean 对象是可以比较大小的(这个有些意外,平时开发中好像从来没有对布尔类型做过大小比较),那么到底是怎么一个比较规则呢?下面先看一下比较大代码:

    public intcompareTo(Boolean b) {return compare(this.value, b.value);

    }public static intcompare(boolean x, boolean y) {return (x == y) ? 0 : (x ? 1 : -1);

    }

    可以看出:对于 compareTo(Boolean b) 方法,当当前对象和参数b指定对象同为 true 或者同为 false 时,返回0;否则当当前对象值为 true 时返回 1;否则返回 -1。根据 comparable 接口的常规约定:@return  a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. 我们可以看出,java在对布尔值比较大小时认为 true > false(姑且可以这么解释以方便记忆 compareTo 方法的规则,现实中真假应该是没有大小之说的吧)

    4.2. getBoolean

    该方法尝试获取一个由参数指定的名称的布尔类型的系统属性值(详细的可以去了解 System 类),如果该属性不存在或者不是布尔类型(所谓布尔类型,就是忽略大小写的 “true” 或者 “false” 字符串),都会返回 false;否则返回该系统属性的布尔值。代码:

    * If there is no property with the specified name, or ifthe specified* name is empty or null, then {@code false} isreturned.*

    *@param name the system property name.*@return the {@code boolean} value of the system property.* @throws SecurityException for the same reasons as

    *{@link System#getProperty(String) System.getProperty}*@see java.lang.System#getProperty(java.lang.String)*@see java.lang.System#getProperty(java.lang.String, java.lang.String)*/

    public staticboolean getBoolean(String name) {

    boolean result= false;try{

    result=parseBoolean(System.getProperty(name));

    }catch (IllegalArgumentException |NullPointerException e) {

    }returnresult;

    }

    4.3. hashCode 方法

    hashCode 是顶级类 Object 定义的基础方法之一,Boolean 对该方法进行了重写。该方法只可能返回 1231 和 1237 两个值。既然布尔只有两种值,那么 hashCode 也只有两个值,理所当然,顺理成章。(如果想问为什么偏偏是这两个数的朋友们就去了解一下 hashCode 方法设计的初衷和哈希表吧)

    /**

    * Returns a hash code for this {@code Boolean} object.

    *

    * @return the integer {@code 1231} if this object represents

    * {@code true}; returns the integer {@code 1237} if this

    * object represents {@code false}.*/@Overridepublic inthashCode() {returnBoolean.hashCode(value);

    }/**

    * Returns a hash code for a {@code boolean} value; compatible with

    * {@code Boolean.hashCode()}.

    *

    * @param value the value to hash

    * @return a hash code value for a {@code boolean} value.

    * @since 1.8*/

    public static inthashCode(boolean value) {return value ? 1231 : 1237;

    }

    4.4. equals 方法

    Boolean 类也重写了 equals 方法,当且仅当参数指定的对象也是 Boolean 实例且与当前对象真假值相同时返回 true。

    publicboolean equals(Object obj) {if(obj instanceof Boolean) {return value ==((Boolean)obj).booleanValue();

    }return false;

    }

    很显然,Boolean 对象遵循 hashCode 和 equals 方法的常规约定。

    5. 划重点

    5.1. Boolean 是最终类,不可被继承;

    5.2. 构造 Boolean 对象,建议使用静态工厂方法 valueOf ,而不是构造方法(因为 valueOf 使用静态缓存),这样比较节省时间和空间;

    5.3. Boolean 实现了 comparable 接口,可以比较大小,java 默认为 true> false;

    5.4. Boolean 的 hashCode() 方法返回 1231(true 时)或 1237(false 时),且与 equals 方法遵循常规约定;

    展开全文
  • 但是这样的json串在前后端分离使用中并不满足实际的效果,因此需要进行相应的封装,以满足前端能够正确处理获取的数据。一、准备1.1 使用的是fastjson,因此需要pom文件引入包版本随你com.alibabafastjson1....

    前言

    首先,采用的是springboot,在controller中使用了@RestController或者@ResponseBody注解,返回的数据本身就是json格式。但是这样的json串在前后端分离使用中并不满足实际的效果,因此需要进行相应的封装,以满足前端能够正确处理获取的数据。

    一、准备

    1.1 使用的是fastjson,因此需要pom文件引入包

    版本随你

    com.alibaba

    fastjson

    1.2.58

    1.2 统一的返回规范必不可少

    一般情况下,状态、信息、数据这三项已经满足大部分需要。如果需求特殊可以自己修改。

    序列化

    值得说一下的是重写tostring时就将其转换为json串JSON.toJSONString(this);。本文所用的返回类进行了实例化,因此采用JSON.方法,也可以通过JSONObject(已经实现序列化,返回类不需要再次序列化)的方发进行转换。

    db331811a2e733eda33d51a7b4db4cd0.png

    为空处理

    利用fastjson自带的注解来处理返回时无值得情况,统一显示为null。@JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue})

    import java.io.Serializable;

    import com.alibaba.fastjson.JSON;

    import com.alibaba.fastjson.annotation.JSONField;

    import com.alibaba.fastjson.serializer.SerializerFeature;

    /**

    *

    * @Description: 统一API响应结果封装

    * @author ZhiPengyu

    * @date: 2020年4月29日 下午2:48:18

    */

    public class ResponseBody implements Serializable {

    /**

    *

    */

    private static final long serialVersionUID = 1886106011131539131L;

    private String code;

    private String message;

    @JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue})

    private Object data;

    /* set and get */

    public String getCode() {

    return code;

    }

    public void setCode(String code) {

    this.code = code;

    }

    public String getMessage() {

    return message;

    }

    public void setMessage(String message) {

    this.message = message;

    }

    public Object getData() {

    return data;

    }

    public void setData(Object data) {

    this.data = data;

    }

    /* 构造 */

    public ResponseBody() {

    super();

    // TODO Auto-generated constructor stub

    }

    public ResponseBody(String code, String message, Object data) {

    super();

    this.code = code;

    this.message = message;

    this.data = data;

    }

    /**

    * 默认成功或者失败,无数据

    * @param resultCode

    */

    public ResponseBody(ResultCode resultCode) {

    this.code = resultCode.getCode();

    this.message = resultCode.getMessage();

    }

    /**

    * 枚举结果以及获取数据

    * @param resultCode

    * @param data

    */

    public ResponseBody(ResultCode resultCode,String message) {

    this.code = resultCode.getCode();

    this.message = message;

    }

    /**

    * 枚举结果以及获取数据

    * @param resultCode

    * @param data

    */

    public ResponseBody(ResultCode resultCode,Object data) {

    this.code = resultCode.getCode();

    this.message = resultCode.getMessage();

    this.data = data;

    }

    @Override

    public String toString() {

    return JSON.toJSONString(this);

    }

    }

    二、封装

    为了更好的进行操作,将操作细节隐藏封装。

    2.1枚举

    就是状态码的统一操作,这样是更加规范的,对前端也一样。

    /**

    *

    * @Description: 响应码枚举,参考HTTP状态码的语义

    * @author ZhiPengyu

    * @date: 2020年4月29日 上午9:27:40

    */

    public enum ResultCode {

    /* 成功 */

    SUCCESS("200", "Success!"),

    /* 失败 */

    FAIL("400", "Failure!"),

    /* 参考HTTP状态码 */

    NO_PERMISSION("403", "Need Authorities!"),//没有权限

    LOGIN_NO("402", "Need Login!"),//未登录

    LOGIN_FAIL("401", "Login Failure!"),//登录失败

    LOGIN_SUCCESS("200", "Login Success!"),//登录成功

    LOGOUT_SUCCESS("200", "Logout Success!"),//退出登录

    SESSION_EXPIRES("101", "Session Expires!"),//会话到期

    SESSION_EXPIRES_OTHER_LOGIN("101", "Session Expires!Other users login!"),//会话到期,其他用户登录

    private String code;

    private String message;

    public String getCode() {

    return code;

    }

    public void setCode(String code) {

    this.code = code;

    }

    public String getMessage() {

    return message;

    }

    public void setMessage(String message) {

    this.message = message;

    }

    /**

    *

    * @param code

    * @param message

    */

    ResultCode(String code, String message) {

    this.code = code;

    this.message = message;

    }

    }

    2.2封装

    利用**@Component**注解简化用户在返回数据是复杂复制操作,同时减少自定义的使用,以枚举为主,可以不断添加。

    import org.springframework.stereotype.Component;

    @Component

    public class ResultGenerator{

    /**

    * 默认成功,无数据

    * @return

    */

    public ResponseBody getSuccessResult() {

    return new ResponseBody(ResultCode.SUCCESS);

    }

    /**

    * 默认成功,有数据

    * @param data

    * @return

    */

    public ResponseBody getSuccessResult(Object data) {

    return new ResponseBody(ResultCode.SUCCESS,data);

    }

    /**

    * 默认失败,无数据

    * @return

    */

    public ResponseBody getFailResult() {

    return new ResponseBody(ResultCode.FAIL);

    }

    /**

    * 默认失败

    * @param message 自定义失败信息

    * @return

    */

    public ResponseBody getFailResult(String message) {

    return new ResponseBody(ResultCode.FAIL,message);

    }

    /**

    * 采用枚举中的状态无数据返回

    * @param resultCode 响应码枚举

    * @param data

    * @return

    */

    public ResponseBody getFreeResult(ResultCode resultCode) {

    return new ResponseBody(resultCode);

    }

    /**

    * 采用枚举中的状态带数据返回

    * @param resultCode 响应码枚举

    * @param data

    * @return

    */

    public ResponseBody getFreeResult(ResultCode resultCode, Object data) {

    return new ResponseBody(resultCode, data);

    }

    /**

    * 自定义返回信息

    * @param code 响应码

    * @param message 自定义失败信息

    * @param data

    * @return

    */

    public ResponseBody getFreeResult(String code, String message, Object data) {

    return new ResponseBody(code, message, data);

    }

    }

    三、使用

    以往都是在controller进行new操作同时,此时可以通过**@Autowired**注解调用并直接赋值返回。

    cbf4abfac82f6df3e0b370aacca7a5b5.png

    如上图所示,通过不同的方式进行对比。

    3.1未完全封装

    @PreAuthorize("hasRole('ROLE_admin')")

    @RequestMapping(value = "getSysUserAdmin")

    public ResponseBody getSysUserAdmin() {

    ResponseBody responseBody = new ResponseBody();

    responseBody.setCode("200");

    responseBody.setMessage("Sccess!");

    List sysUser = sysUserService.select(null, null);

    responseBody.setData(JSON.toJSONString(sysUser));

    return responseBody;

    }

    {

    "code": "200",

    "message": "Sccess!",

    "data": "[{\"company\":\"科研诚信\",\"createtime\":1586942036000,\"parentName\":\"admin\",\"password\":\"$2a$10$XlftNY9T52IbLlVAT6Nx7ezyYlcSFkVzC.3n3h5jihyzo1g/KtAPa\",\"pwdRole\":1,\"role\":2,\"status\":1,\"uploadAmount\":3,\"uploadResidue\":0,\"userId\":27,\"userIp\":\"89\",\"username\":\"admin1\"}]"

    }

    3.2完全封装

    可以看出差距还是不小的。

    @Autowired

    ResultGenerator resultGenerator;

    @RequestMapping(value = "testjson")

    public ResponseBody testjson() {

    List sysUser = sysUserService.selectSysUserByUnameOrCompany(null, null);

    return resultGenerator.getSuccessResult(sysUser);

    }

    {

    "code": "200",

    "message": "Success!",

    "data": [

    {

    "userId": 27,

    "username": "admin1",

    "password": "$2a$10$XlftNY9T52IbLlVAT6Nx7ezyYlcSFkVzC.3n3h5jihyzo1g/KtAPa",

    "parentName": "admin",

    "company": "科研诚信",

    "cpyBranch": null,

    "userIp": "89",

    "uploadAmount": 3,

    "uploadResidue": 0,

    "status": 1,

    "role": 2,

    "pwdRole": 1,

    "createtime": "2020-04-15T09:13:56.000+0000",

    "startTime": null,

    "endTime": null,

    "phoneNumber": null,

    "mail": null,

    "remark": null

    }

    ]

    }

    四、总结

    此文是在查看一些文章之后的总结修改,大同小异,方式多种多样。再次仅说了一种,那些地方说不不对,还请留言矫正啊。

    展开全文
  • JavaArray和ArrayList

    2021-03-06 05:50:39
    java.util.Arrays类包含用来操作数组(比如排序和搜索)的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。除非特别注明,否则如果指定数组引用为 null,则此类中的方法都会抛出NullPointerException。...
  • 数组封装类1、基础数组语法数组声明,支持:dataType[] arrayRefVar或dataType arrayRefVar[]两种方式。推荐采用dataType[] arrayRefVar方式。创建数组:dataType[] arrayRefVar = new dataType[arraySize]或...
  • 先看封装好的api例子:js的sort排序java的compareTo排序自己模拟的代码(JS)function compareTo(a,b){return a-b;//a-b为从下到大 b-a为从大到小}Object.prototype.newSort = function(Func){const flag = ...
  • 1)精辟阐述:可以将ArrayList想象成一种“会自动扩增容量的Array”。2)Array([]):最高效;但是其容量固定且无法动态改变;ArrayList:容量可动态增长;但牺牲效率;...4)Java中一切皆对象,Array也是...
  • 本文实例讲述了Java封装数组实现在数组中查询元素和修改元素操作。分享给大家供大家参考,具体如下:前言:在上一小节中,我们已经对如何往数组中添加一个元素的方法进行了编写,此节中我们就如何查询出数组中元素与...
  • array vs ArrayList in Java (Javaarray和ArrayList的比较)通过一些点来比较两个不同的事情是最好的方式,这样会使大家容易理解他们的不同点。所以让我们来看看有哪些点能够让我们比较array 和ArrayList。▶1) ...
  • Java Stack<E> Array

    2021-02-28 17:12:04
    JDK自带的实现了Array接口的数组 LinkedArray和ArrayList都是大小62616964757a686964616fe4b893e5b19e31333262356164可变的,其中linked底层使用链表实现不必说,ArrayList底层虽然使用数组实现,但是当插入元素已满...
  • 之前一直分不清楚java中的array,list。同时对set,map,list的用法彻底迷糊,直到看到了这篇文章,讲解的很清楚。世间上本来没有集合,(只有数组参考C语言)但有人想要,所以有了集合有人想有可以自动扩展的数组,所以有了...
  • 简介 最近看的书有点杂,看到GeekTime的《设计模式之美》,其中对封装的对我感触很深,花了一天时间研究了一下,方便后面回看,在这里记录一下,回想几年前无脑的getter() setter(),哈哈,真是感觉自己...import java.m
  • Java 封装与关键字

    2021-04-01 16:59:14
    import java.util.Array; (三个都是并列写出) import java.util.HashMap; ———————————————————————————— 以上可以化为: import java.util.*; 5. 如果使用的类或接口是 java.lang 包下...
  • Java8新特性Stream流api实用的一些封装

    热门讨论 2021-03-24 11:21:15
    Java Stream API进行一些简单的封装功能介绍List分组根据字段简单分组简单分组测试选择返回字段分组选择返回字段分组测试合并结果集分组合并结果集分组测试分组后对结果集进行处理测试分组后统计每组的数量测试对...
  • 'use strict';//启用严格模式var oap={},obj_type={},core_toString=obj_type.toString,hasOwn = obj_type....var type_arr = "Boolean Number String Function Array Date RegExp Object Error".split(" ");...
  • Zabbix官方提供了Rest API的文档,并推荐了第三方库,但这些库都是zabbix老版本(2.2,2.4/3.0)的库,多年未更新过,且变量/方法命名都不符合java的驼峰式规范。所以开发中基于3.4的文档,自己封装了一套库。结合二次...
  • 之前一直分不清楚java中的array,list。同时对set,map,list的用法彻底迷糊,直到看到了这篇文章,讲解的很清楚。世间上本来没有集合,(只有数组参考C语言)但有人想要,所以有了集合有人想有可以自动扩展的数组,所以有了...
  • 软件介绍J2V8 是 V8 引擎的 Java 封装版本,注重性能和紧密集成。示例代码:V8v8=V8.createV8Runtime();V8Arrayresult=v8.executeArrayScript("varbuffer=newArrayBuffer(256);\n"+"vari32=newInt32Array(buffer);\n...
  • 昨天去了一个java的实习面试,发现有好多java最基础的数据结构对于博主来说反而感到陌生,在面试官问一些常见的例如HashMap这样的数据结构,博主能回答的头头是道,但是在问到Array和ArrayList的区别和联系之后,却...
  • 二次封装JAVA数组

    2021-03-23 16:59:27
    一、前言JAVA数组缺点:一旦定义了数组,数组...由于Java数组有点笨重,操作数组的时候有点不方便,我们不得不自己封装自己数组,当然现在有很多工具类例如ArrayList,它就可以完全代替数组。下面我们将演示如何对数...
  • 本文实例讲述了Java封装数组之改进为泛型数组操作。分享给大家供大家参考,具体如下:前言:通过上一节我们对我们需要封装的数组,进行了基本的增删改查的封装,但只局限于int类型的操作,为了能提供多种类型数组的...
  • Java对象映射工具类封装

    千次阅读 2021-11-18 14:11:34
    文章主要记录一下工作中封装的对象转换工具类 /** * Spring的BeanUtils只能映射类型相同的属性,无法满足将Date转字符串,枚举类型转换等需求 * 所以将Spring的BeanUtils源码复制出来,自己扩展了映射逻辑 */ ...
  • 本文实例讲述了Java封装数组实现包含、搜索和删除元素操作。分享给大家供大家参考,具体如下:前言:在上一小节中我们已经会了如何获取和如何修改数组中的元素,在本小节中我们将继续学习如何判断某个元素是否在数组...
  • Java封装封装性在Java当中的体现:1.方法就是一种封装2.关键字private也是一种封装封装就是将一些细节信息.隐藏起来,对于外界不可见。public class Method {public static void main(String[] args) {int[] array =...
  • 可以谷歌的Gson就是为处理java对象和json之间转换开发的框架,其可以很简单、方便的对封装java对象和json格式文本之间的转换,包括java工具类集合之间的转换也很方便;(2)。相对json_lib框架来说,只需要一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 98,437
精华内容 39,374
关键字:

java封装array

java 订阅