JSON解析、JAVA常用的工具类、JAVA集合框架、JAVA泛型、枚举

最新推荐文章于 2023-08-31 16:25:28 发布
最新推荐文章于 2023-08-31 16:25:28 发布
阅读量204 收藏
点赞数

JSON

简介

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C、C++、C#、Java、JavaScript、Perl、Python等）。这些特性使JSON成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成(网络传输速率)。

JSON 语法规则

JSON 语法是 JavaScript 对象表示语法的子集。
1. 数据在名称/值对中
2. 数据由逗号分隔
3. 花括号保存对象
4. 方括号保存数组

与XML比较

XML和JSON都使用结构化方法来标记数据，下面来做一个简单的比较。
用XML表示中国部分省市数据如下：

<?xml version="1.0" encoding="utf-8"?>
<country>
    <name>中国</name>
    <province>
        <name>黑龙江</name>
        <cities>
            <city>哈尔滨</city>
            <city>大庆</city>
        </cities>
    </province>
    <province>
        <name>广东</name>
        <cities>
            <city>广州</city>
            <city>深圳</city>
            <city>珠海</city>
        </cities>
    </province>
    <province>
        <name>台湾</name>
        <cities>
            <city>台北</city>
            <city>高雄</city>
        </cities>
    </province>
    <province>
        <name>新疆</name>
        <cities>
            <city>乌鲁木齐</city>
        </cities>
    </province>
</country>
  
  
  • 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

用JSON表示如下：

{
    "name": "中国",
    "province": [{
        "name": "黑龙江",
        "cities": {
            "city": ["哈尔滨", "大庆"]
        }
    }, {
        "name": "广东",
        "cities": {
            "city": ["广州", "深圳", "珠海"]
        }
    }, {
        "name": "台湾",
        "cities": {
            "city": ["台北", "高雄"]
        }
    }, {
        "name": "新疆",
        "cities": {
            "city": ["乌鲁木齐"]
        }
    }]
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

编码的可读性，xml有明显的优势，毕竟人类的语言更贴近这样的说明结构。json读起来更像一个数据块，读起来就比较费解了。不过，我们读起来费解的语言，恰恰是适合机器阅读，所以通过json的索引.province[0].name就能够读取“黑龙江”这个值。
编码的手写难度来说，xml还是舒服一些，好读当然就好写。不过写出来的字符JSON就明显少很多。去掉空白制表以及换行的话，JSON就是密密麻麻的有用数据，而xml却包含很多重复的标记字符。

代码示例

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class JsonTest {
    public static void main(String[] args) {
        String s=creatJson();
        if(s!=null){  //解析JSON文本
            JSONObject clazz=JSONObject.fromObject(s);
            System.out.println("班级："+clazz.getString("班级"));
            System.out.println("班级人数："+clazz.getString("班级人数"));
            JSONArray array=clazz.getJSONArray("学生");
            for (int i = 0; i < array.size(); i++) {
                JSONObject obj =array.getJSONObject(i);
                System.out.print("学生姓名："+obj.getString("姓名")+"\t");
                System.out.println("学生年龄："+obj.getString("年龄"));

            }
        }
    }

    private static String creatJson() {//生成JSON文本格式
        JSONObject obj1 = new JSONObject();
        obj1.put("姓名", "张三");
        obj1.put("年龄", "18");
        JSONObject obj2 = new JSONObject();
        obj2.put("姓名", "李四");
        obj2.put("年龄", "19");
        JSONObject obj3 = new JSONObject();
        obj3.put("姓名", "王五");
        obj3.put("年龄", "20");
        JSONArray array = new JSONArray();
        array.add(obj1);
        array.add(obj2);
        array.add(obj3);
        JSONObject clazz = new JSONObject();
        clazz.put("班级", "2012163");
        clazz.put("班级人数", "27");
        clazz.put("学生", array);
        System.out.println(clazz.toString());
        return clazz.toString();
    }
}
  
  
  • 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

运行结果：
这里写图片描述
另一种生成JSON文本的方法

//创建一个Student类
public class Student {
    private String name;
    private int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public int getage() {
        return age;
    }
    public void setage(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

创建JsonTest类

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class JsonTest {
    public static void main(String[] args) {
        Student zhangsan = new Student("张三", 12);
        Student lisi = new Student("李四", 12);
        Student wangwu = new Student("王五", 12);
        Student zhaoliu = new Student("赵六", 12);
        JSONObject obj= new JSONObject();
        JSONArray array = new JSONArray();
        array.add(zhangsan);
        array.add(lisi);
        array.add(wangwu);
        array.add(zhaoliu);
        obj.put("学生", array);
        System.out.println(obj.toString());
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

运行结果：
这里写图片描述

Math类

简介

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

字段摘要

  1. static final double E （常量）
    比任何其他值都更接近 e（即自然对数的底数）的 double 值。
  2. static final double PI （常量）
    比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。

方法摘要

  1. public static double sqrt(double a)返回正确舍入的 double 值的正平方根。
  2. 向上取整
    public static double ceil(double a)返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
  3. 向下取整
    public static double floor(double a)返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
  4. 数学上的四舍五入
    public static int round(float a)返回最接近参数的 int。结果将舍入为整数：加上 1/2，对结果调用 floor 并将所得结果强制转换为 int 类型。换句话说，结果等于以下表达式的值： (int)Math.floor(a + 0.5f)。
  5. public static double random()返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。
  6. public static int max(int a,int b)返回两个 int 值中较大的一个。
  7. public static int min(int a,int b)返回两个 int 值中较小的一个。

Date类

构造方法摘要

Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

方法摘要

public long getTime()返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

Calendar类

它是一个抽象类

字段

  1. public static final int YEAR指示年的 get 和 set 的字段数字。
  2. public static final int MONTH指示月份的 get 和 set 的字段数字。
    注意：第一个月份为0
  3. public static final int DATEget 和 set 的字段数字，指示一个月中的某天。

方法摘要

  1. public static Calendar getInstance()使用默认时区和语言环境获得一个日历。返回的 Calendar 基于当前时间，使用了默认时区和默认语言环境。
    返回：一个 Calendar。
  2. public final Date getTime()返回一个表示此 Calendar 时间值（从历元至现在的毫秒偏移量）的 Date 对象。
    返回：表示时间值的 Date。
  3. public long getTimeInMillis()返回此 Calendar 的时间值，以毫秒为单位。
    返回：当前时间，以从历元至现在所经过的 UTC 毫秒数形式。
  4. public abstract void add(int field,int amount)根据日历的规则，为给定的日历字段添加或减去指定的时间量。

代码示例

import java.util.Calendar;
import java.util.Date;

public class ShiJian {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        System.out.println(date.getTime());//返回格林尼治时间之后的毫秒数
        Calendar cal= Calendar.getInstance();       
        System.out.println(cal.getTime());
        System.out.println(cal.getTimeInMillis());//返回格林尼治时间之后的毫秒数
        System.out.println(cal.get(Calendar.YEAR)+"年"+(cal.get(Calendar.MONTH)+1)+"月"+cal.get(Calendar.DATE)+"日");
        cal.add(Calendar.DATE, 50);//往后加50天的时间
        System.out.println(cal.get(Calendar.YEAR)+"年"+(cal.get(Calendar.MONTH)+1)+"月"+cal.get(Calendar.DATE)+"日");      
    }   
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

运行结果：
这里写图片描述

SimpleDateFormat类

简介

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

构造方法

SimpleDateFormat()
用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。

方法摘要

  1. public StringBuffer format(Date date,StringBuffertoAppendTo,FieldPosition pos)
    将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。
    返回：格式化的日期-时间字符串。
  2. public Date parse(String text,ParsePosition pos)解析字符串的文本，生成 Date。
    返回：从字符串进行解析的 Date。如果发生错误，则返回 null。

代码示例

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Time {
    public static void main(String[] args) {
        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy/MM/dd kk:mm:ss");
        System.out.println(format.format(date));//按所要格式输出当前时间
        String s = "2015/07/24 11:40:20";
        try {
            Date date1 = format.parse(s);//按格式解析一个时间字符串
            System.out.println(date1.getDate());
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

运行结果：
这里写图片描述

集合

分类

这里写图片描述

ArrayList

简介

ArrayList里边的元素不唯一，有序。
内存空间连续。
元素遍历快，增删慢。

方法摘要

  1. public int size()返回此列表中的元素数。
  2. public boolean isEmpty()如果此列表中没有元素，则返回 true。
  3. public boolean contains(Object o)如果此列表中包含指定的元素，则返回 true 。
  4. public int indexOf(Object o)返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
  5. public int lastIndexOf(Object o)返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
  6. public E get(int index)返回此列表中指定位置上的元素。
  7. public E set(int index,E element)用指定的元素替代此列表中指定位置上的元素。
  8. public void add(int index,E element)将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。
  9. public E remove(int index)移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1）。

Collections类

简介

java.util.Collections

方法摘要

1.public static <T extends Comparable<? super T>> void sort(List<T> list)根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。
2.public static <T> void sort(List<T> list,Comparator<? super T> c)根据指定比较器产生的顺序对指定列表进行排序。
Comparator接口的方法：public int compare(T o1,T o2)比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

代码示例

创建一个Student 类

public class Student {
    private String name;
    private int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public int getage() {
        return age;
    }
    public void setage(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

编写一个比较的类

import java.util.Comparator;

public class paixu implements Comparator<Student> {

    @Override
    public int compare(Student s1, Student s2) {
        return s1.getage() - s2.getage();//按年龄大小排序
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

创建JiheTset类

mport java.util.ArrayList;
import java.util.Collections;

public class JiheTest {  //ArrayList
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<Student>();
        Student zhangsan= new Student("张三", 11);
        Student lisi= new Student("李四", 12);
        Student wangwu= new Student("王五", 13);
        list.add(zhangsan);
        list.add(lisi);
        list.add(wangwu);
        list.add(1, wangwu);
        list.get(3).setName("我换了个名字");
        System.out.println(list.size());
        Collections.sort(list, new paixu());//排序
        for(Student s:list){ //foreach语句
            System.out.println(s.getName());
        }   
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

运行结果：
这里写图片描述

HashSet类

简介

元素唯一，无序。
此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

方法摘要

  1. public Iterator iterator()返回对此 set 中元素进行迭代的迭代器。返回元素的顺序并不是特定的。
    返回：对此 set 中元素进行迭代的 Iterator
  2. public int size()返回此 set 中的元素的数量（set 的容量）。
  3. public boolean isEmpty()如果此 set 不包含任何元素，则返回 true。
  4. public boolean contains(Object o)如果此 set 包含指定元素，则返回 true。
  5. public boolean add(E e)如果此 set 中尚未包含指定元素，则添加指定元素。
  6. public boolean remove(Object o)如果指定元素存在于此 set 中，则将其移除。
  7. public void clear()从此 set 中移除所有元素。此调用返回后，该 set 将为空。

代码示例

import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
//随机生成10个随机数，放入一个HashSet中
public class Demo {  //HashSet 
    public static void main(String[] args) {
        HashSet<Integer> set = new HashSet<Integer>();
        Random random = new Random();
        while (set.size() < 10) {
            int i = random.nextInt(90) + 10;
            set.add(i);
        }
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println(set.size());
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

HashMap类

简介

存在一个K到V的一一映射，且K值不允许重复。
K - 此映射所维护的键的类型，V - 所映射值的类型
基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

方法摘要

  1. public int size()返回此映射中的键-值映射关系数。
  2. public boolean isEmpty()如果此映射不包含键-值映射关系，则返回 true。
  3. public V get(Object key)返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
  4. public boolean containsKey(Object key)如果此映射包含对于指定键的映射关系，则返回 true。
  5. public V put(K key,V value)在此映射中关联指定值与指定键。如果该映射以前包含了一个该键的映射关系，则旧值被替换。
  6. public V remove(Object key)从此映射中移除指定键的映射关系（如果存在）。
  7. public Set keySet()返回此映射中所包含的键的 Set 视图。
  8. public Set entrySet()返回此映射所包含的映射关系的 Set 视图。

代码示例

创建一个Student类

public class Student {
    private String name;
    private int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public int getage() {
        return age;
    }
    public void setage(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

创建Test类

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        HashMap<Integer, Student> map = new HashMap<>();
        Student zhangsan = new Student("张三", 18);
        Student lisi = new Student("李四", 19);
        Student wangwu = new Student("王五", 20);
        map.put(201216301, zhangsan);
        map.put(201216302, lisi);
        map.put(201216303, wangwu);

        Set<Integer> keys = map.keySet();
        Iterator<Integer> it = keys.iterator();
        while (it.hasNext()) {
            Integer i = it.next();
            System.out.println(i + "----" + map.get(i).getName());
        }
        //另一种写法
        for (Integer key : map.keySet()) {
            System.out.println(key + "----" + (String) map.get(key).getName());
        }
    }
}
  
  
  • 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

运行结果：
这里写图片描述

泛型

泛型集合

ArrayList<Integer> list = new ArrayList<Integer>();
  
  
  • 1

<>中写的数据类型必须是封装类和引用数据类型

HashMap<String,String> map = new HashMap<String,String>(); 
  
  
  • 1

泛型类

public class 类名<T>{
    private T 变量名1;
    private T 变量名1;
}
  
  
  • 1
  • 2
  • 3
  • 4

泛型方法

泛型方法的语法

[访问权限修饰符] [static] [final] <类型参数列表> 返回值类型 方法名([形式参数列表])

 public static <T extends Comparable> Pair<T> minmax(T[] a)  //<T extends Comparable> 是指 类型参数列表
  
  
  • 1

【方法中传入或返回的泛型类型由调用方法时所设置的参数类型所决定。】可用extends 和 super 关键字分别来指定上限和下限类型。
Pair 是返回值。minmax 方法名，T[] a 形式参数列表

代码示例

创建Pair泛型类

public class Pair<T> {
    private T first;
    private T second;
    public Pair(){
        first=null;
        second=null;
    }
    public Pair(T first,T second){
        this.first=first;
        this.second=second;
    }
    public T getFirst() {
        return first;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public T getSecond() {
        return second;
    }
    public void setSecond(T second) {
        this.second = second;
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

创建ArrayAlg类

public class ArrayAlg {
    public static <T extends Comparable<T>> Pair<T> minmax(T[] a) {
        if (a == null || a.length == 0) {
            return null;
        }
        T min = a[0];
        T max = a[0];
        for (int i = 0; i < a.length; i++) {
            if (min.compareTo(a[i]) > 0) {
                min = a[i];
            }
            if (max.compareTo(a[i]) < 0) {
                max = a[i];
            }
        }
        return new Pair<T>(min,max);
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

创建Test类

public class Test {
    public static void main(String[] args) {
        Integer[]a={1,2,3,4};
        Pair<Integer> pair = ArrayAlg.minmax(a);
        System.out.println("最小值为："+pair.getFirst());
        System.out.println("最大值为："+pair.getSecond());
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

运行结果：
这里写图片描述

枚举

用法一：常量
在JDK1.5之前，我们定义常量都是：publicstaticfianl….。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

　　public enum Color {
    　　RED, GREEN, BLANK, YELLOW
　　}
  
  
  • 1
  • 2
  • 3

用法二：switch
JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。

　  enum Signal {
    　　GREEN, YELLOW, RED
　　}
　  public class TrafficLight {
        Signal color = Signal.RED;
    　  public void change() {
        　  switch (color) {
        　  case RED:
        　  color = Signal.GREEN;
        　　 break;
        　　case YELLOW:
        　　color = Signal.RED;
        　　break;
        　　case GREEN:
        　　color = Signal.YELLOW;
        　　break;
        　　}
    　　}
　}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

用法三：向枚举中添加新方法
如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且Java要求必须先定义enum实例。

　　public enum Color {
    　　RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    　　// 成员变量
    　　private String name;
    　　private int index;
    　　// 构造方法
    　　private Color(String name, int index) {
        　　this.name = name;
        　　this.index = index;
    　　}
    　　// 普通方法
    　　public static String getName(int index) {
        　　for (Color c : Color.values()) {
            　　if (c.getIndex() == index) {
            　　return c.name;
            　　}
        　　}
        　　return null;
    　　}
    　　// get set 方法
    　　public String getName() {
        　　return name;
    　　}
    　　public void setName(String name) {
        　　this.name = name;
    　　}
    　　public int getIndex() {
        　　return index;
    　　}
    　　public void setIndex(int index) {
        　　this.index = index;
    　　}
　　}
  
  
  • 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

用法四：覆盖枚举的方法
下面给出一个toString()方法覆盖的例子。

　　public enum Color {
    　　RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    　　// 成员变量
    　　private String name;
    　　private int index;
    　　// 构造方法
    　　private Color(String name, int index) {
        　　this.name = name;
        　　this.index = index;
    　　}
    　　//覆盖方法
    　　@Override
    　　public String toString() {
        　　return this.index+"_"+this.name;
    　　}
　　}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

用法五：实现接口
所有的枚举都继承自java.lang.Enum类。由于Java不支持多继承，所以枚举对象不能再继承其他类。

　　public interface Behaviour {
    　　void print();
    　　String getInfo();
　　}
　  public enum Color implements Behaviour{
    　　RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
    　　// 成员变量
    　　private String name;
    　　private int index;
    　　// 构造方法
    　　private Color(String name, int index) {
        　　this.name = name;
        　　this.index = index;
    　　}
    　　//接口方法
    　　@Override
    　　public String getInfo() {
        　　return this.name;
    　　}
    　　//接口方法
    　　@Override
    　　public void print() {
        　　System.out.println(this.index+":"+this.name);
    　　}
　　}
  
  
  • 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

用法六：使用接口组织枚举

　　public interface Food {
    　　enum Coffee implements Food{
        　　BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
    　　}
    　　enum Dessert implements Food{
        　　FRUIT, CAKE, GELATO
    　　}
　　}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

用法七：关于枚举集合的使用
java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。

代码示例

public enum Color {//枚举
    RED,ORANGE,YELLOW,GREEN,BULE,PURPLE
}
  
  
  • 1
  • 2
  • 3

创建Test类

public class Test {
    public static void main(String[] args) {
        Color color = Color.RED;
        switch (color) {
        case RED:
            System.out.println("这是红色");
            break;
        case ORANGE:
            System.out.println("这是橙色");
            break;
        case YELLOW:
            System.out.println("这是黄色");
            break;
        default:
            break;
        }
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

运行结果：
这里写图片描述

展开更多
名称不能为null
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详解Java常用工具类—泛型
08-26
主要介绍了Java常用工具类—泛型，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java集合、泛型和枚举
06-14
Java集合、泛型和枚举；Java集合、泛型和枚举；Java集合、泛型和枚举；Java集合、泛型和枚举；
java枚举转json数字_jackson 枚举 enum json 解析类型 返回数字 或者自定义文字
weixin_34237941的博客
02-27 932
jackson解析枚举时一般返回MALE，FEMALE，如果想返回文字或者数字怎么办。网上stackflow上大都用@JsonCreator官网提供的方法(下面的方法)更好点，想返回什么就在属性的get方法上加 @JsonValue。如果想在不同的方法中返回不同的值就用其他的方法了！packagecom.model;importcom.fasterxml.jackson.annota...
Java-----泛型和工具类
AMT_MUZI的博客
03-30 1073
泛型和工具类 泛型 Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。 常见形式有泛型类、泛型接口、泛型方法。 语法： <T，…> T 称为类型占位符，表示一种引用类型。 好处： （1）提高代码的重用性 （2）放置类型转换异常，提高代码的安全性。 实例一(使用泛型类)： // 泛型类 // 语法：类名<T> // T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开 public class MyGeneric&
Java泛型详解：类型安全的通用编程利器
BASK2312的博客
05-16 400
泛型类和泛型接口是使用泛型类型参数的类和接口。它们在定义中使用泛型类型参数来表示要处理的数据类型。通过在实例化时指定具体的类型参数，我们可以创建泛型类或泛型接口的实例，从而获得处理特定类型数据的能力。泛型方法是在方法定义中使用类型参数的方法。泛型方法可以是普通的方法或静态方法。通过在方法签名中定义类型参数，我们可以在方法内部使用这些类型参数来处理数据，实现更通用的方法逻辑。泛型方法是在方法定义中使用类型参数的方法。它可以在普通方法和静态方法中使用。
JSON与对象（枚举类对象）之间的相互转换
热门推荐
myblog_dhy的专栏
04-13 2万+
最近在处理枚举类型的值的时候遇到了很多问题，现在将他们记录下来，一来以后可以增强自己的记忆，二来让自己坚持一个记笔记的好习惯。也可以供大家参考，提出问题，一起探讨。 问题一：如何在实体类中定义枚举类型的字段（直接上代码） /** * 定义政府文件的来文单位的枚举类 * @author Administrator * */ public enum FromUnit { State
Java 泛型全解析
09-07
主要介绍了Java 泛型的相关资料，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下
详解Java中的 枚举与泛型
08-31
主要介绍了 详解Java中的 枚举与泛型的相关资料,需要的朋友可以参考下
java泛型常用通配符实例解析
08-25
主要介绍了java泛型常用通配符实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
阿里集团高效的json解析工具jar
12-05
阿里集团的高效json解析。并且使用简单。解析速度比json-lib-2.3-jdk15快很多
【java进阶09：集合】泛型、增强for、Collections集合工具类
博客
04-07 238
集合概述什么是集合？有什么用?数组实际上就是一个集合。集合实际上就是一个容器，可以来容纳其他类型的数据。集合为什么在开发中使用的比较多？​ 集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假设连接数据库，数据库当中有10条记录，那么假设把这10条记录查询出来，在java程序中会将10条数据封装成10个java对象，然后将10个java对象放到某一个集合当中，将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。
Java 工具类 ，泛型
NXY78787的博客
05-03 660
工具类 Collections类 方法为主（查看API） Arrays类 Arrays工具类（详情查看API） Arrays提供了数据操作的工具类，包含很多方法 集合和数组之间的转换 数组转成list： 1.数组转集合：asList()；方法 2.集合转数组：toArray();方法 mport java.util.*; /** * Collections工具类 * 在使用二分查找法的前提是先要对集合中的元素进.
JAVA核心技术（1）泛型、常用工具类、集合
molkor的博客
06-23 461
目录 一、泛型 二、Objects工具类 三、Math工具类 四、Arrays工具类 一、泛型 泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定 义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 使用： 多个类型用逗号隔开 <T,B,A,E> 1、定义一个泛型类： public class Person<T> { private T data; priv...
Java中的泛型
weixin_64704029的博客
06-12 331
Object类为最上层的父类，很多程序员为了使程序更为通用，设计程序时通常使传入的值和返回的值都以Object类为主，但是为了防止类型转换异常，Java提供泛型机制，其语法如下类名其中，T是泛型的名字，代表某一种类型，开发者在创建该类对象时需要指定T所代表的时哪种具体的类型，T则采用Object类型。
java树泛型工具类
最新发布
weixin_42895341的博客
08-31 147
JAVA构建树形结构通用工具类 场景说明 案例中的方法说明 构建思路实现 第一步:构建接口TreeFeature 第二步:让需要构建树形结构的类实现该接口并实现方法 第三部创建通用的TreeUtil工具类 到这位置，TreeUtil已经完成来测试,先在实体类中添加点测试数据 编写测试类 输出结果 当有一个新的需要构建树形结构的实体时，只需要实现TreeFeature接口并重写好其中的方法，调用TreeUtil .build即可 场景说明 在日常java开发过程中，经常遇到要把一个扁平结构的数据，处理成为树形
阶段一/常用工具类/Java泛型
xuanshuang的博客
02-21 258
泛型概述 Java SE7及以后的版本中，构造方法中可以省略泛型类型，例如List<String> list = new ArrayList<>(); 泛型变量声明的类型必须匹配传递给实际对象的类型，例如下面这种是不可以的，Cat是Animal类的子类，但是List<Animal> list = new ArrayList<Cat>();这种是不被允许的，会报错，Error:不兼容的类型: java.util.ArrayList<com....
Java中如何使用JSON进行文件解析
weixin_49137294的博客
07-14 5372
在应用JSON时我们最常用Fastjson这个库，Fastjson是阿里巴巴的开源JSON解析库，它可以解析JSON格式的字符串，支持将JavaBean序列化微JSON字符串，也可以从JSON字符串反序列化到JavaBean。在使用Java进行应用程序的开发中，可能会遇到“将Java对象转换成JSON格式”或者“将JSON格式的数据转换成Java对象”的需求。解决方法输出日期字段时，默认格式不符合需求时，可以在定义实体类的Date字段，使用@jsonFie注解的format属性进行格式配置。...
Json不能解析枚举类型解决方案
ChineseCaptainOn的博客
02-17 648
Json不能解析枚举类型解决方案
java集合框架map和泛型
08-13
综上所述，Java集合框架中的Map和泛型可以一起使用，通过泛型可以指定集合中存储的元素类型，增加代码的可读性和类型安全性。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值