Java IO流 、 Properties 、 枚举

最新推荐文章于 2021-01-30 10:25:03 发布
最新推荐文章于 2021-01-30 10:25:03 发布
阅读量418 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chou_out_man/article/details/78205366
版权

一、概述

  • IO流流动的是数据 --- 用于传输数据的API。
  • InputStream\OutputStream   ---   输入输出流
  • 根据流的传输方向分类 ： 
    • 当数据从外部流入程序时  ： 输入流
    • 当数据从程序流向外部时 ： 输出流
  • 根据流的传输形式分类： 
    • 字节流
    • 字符流
  • 不同形式交汇，得到四种基本操作流的类  ， 四个基本流都是抽象类
           输入流      输出流
        字符流          Reader      Writer
        字节流      InputStream            OutputStream     

  • 数据的来源： 硬盘、网络、内存、输入设备
  • 字符输入流示例：
    public class FileWriterDemo1 {

	public static void main(String[] args) throws Exception {

		// 无论这个文件是否存在，都会创建一个新的文件 ，不存在则创建，存在则覆盖
		FileWriter writer = new FileWriter("E:\\a.txt");

		// 写出数据
		// java在底层对字符流设计了一个缓冲区，数据并不是直接写到目的地而是先写到了缓冲区中
		// 等缓冲区满了之后才会将缓冲区中的数据一次性的放到目的地中。
		// 由于缓冲区没有满而代码已经结束，所以数据就死在了缓冲区中
		writer.write("def");

		// 冲刷缓冲区
		// writer.flush();

		// 关闭流对象
		// 流在关闭之前会自动的冲刷缓冲区，以防有数据死在缓冲区中
		writer.close();

		// 流在关闭之后依然存在，依然在占用内存
		writer = null;

		System.out.println(writer);
	}

}

  • 字符输出流示例：
    public class FileReaderDemo2 {

	public static void main(String[] args) throws Exception {

		FileReader reader = new FileReader("E:\\a.txt");

		// 创建一个字符数组作为缓冲区
		char[] cs = new char[5];

		// 定义一个变量来记录每次读取到字符个数
		int len = -1;

		// 读取数据，将数据读取到字符数组中
		while ((len = reader.read(cs)) != -1) {
			System.out.println(new String(cs, 0, len));
		}

		// 关流
		reader.close();
	}

}

  • 字节输入流示例：
    public class FileInputStreamDemo {

	public static void main(String[] args) throws Exception {

		FileInputStream fin = new FileInputStream("E:\\a.txt");

		// 创建一个字节数组作为缓冲区
		byte[] bs = new byte[3];

		// 定义一个变量来记录每次读取的字节个数
		int len = -1;

		while ((len = fin.read(bs)) != -1) {
			System.out.println(new String(bs, 0, len));
		}
		
		fin.close();

	}

}

  • 字节输出流示例：
    public class FileOutputStreamDemo {

	public static void main(String[] args) throws Exception {

		FileOutputStream writer = new FileOutputStream("E:\\c.txt");

		// 没有缓冲区
		writer.write("abc".getBytes());

		// 关流
		writer.close();

	}

}

二、流的异常处理

  • 第一步：流对象外置定义  内置初始化
  • 第二步：防止流对象关闭时出现空指针异常 ，关闭前 对流对象判空
  • 第三步：如果关流失败，则强制释放  ；如果关流成功，则释放流对象 ，释放内存
  • 第四步：防止关流失败 ，在关流之前手动冲刷缓冲区
  • 示例：
    package cn.tedu.io.file;


import java.io.FileWriter;
import java.io.IOException;


public class FileWriterDemo2 {


	public static void main(String[] args) {


		// 流对象要外置定义，在外置定义的时候需要把这个流对象置为null
		FileWriter writer = null;
		try {
			// 内置初始化
			writer = new FileWriter("E:\\b.txt");
			writer.write("abcdefg");
			// 为了防止关流失败导致一部分数据的丢失，因此需要提前进行flush来保证数据的完整性
			writer.flush();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 需要判断流对象是否初始化成功
			if (writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				} finally {
					// 如果关流失败则强制回收流对象以释放文件
					// 如果关流成功则用于释放这个流对象占用的内存
					writer = null;
				}
			}
		}
	}


}

  • 练习： 剪切文件
    public class CutFileDemo {

	public static void main(String[] args) throws Exception {

		// 创建一个file对象指向源文件
		File oldFile = new File("E:\\a.txt");

		// 创建一个输入流指向源文件
		FileReader reader = new FileReader(oldFile);

		// 创建一个输出流来指向新文件
		FileWriter writer = new FileWriter("D:\\a.txt");

		// 创建一个字符数组作为缓冲区
		char[] cs = new char[10];

		// 定义一个变量记录每次读取到字符个数
		int len = -1;

		// 读取数据
		while ((len = reader.read(cs)) != -1) {
			// 将读取到数据写出
			writer.write(cs, 0, len);
		}

		// 关流
		reader.close();
		writer.close();

		// 删除源文件
		oldFile.delete();

	}

}


三、缓冲流

  • BufferedReader :从字符输入流中读取数据 ， 提供一个缓冲区 ， 允许按行读取
  • BufferWriter ： newLine() 产生新的一行。
  • 字符输入缓冲流示例：
    public class BufferedReaderDemo {

	public static void main(String[] args) throws Exception {
		
		// 实际上读取数据的流是FileReader, BufferedReader的作用是为这个流提供了一个缓冲区
		BufferedReader reader = new BufferedReader(new FileReader("E:\\a.txt"));
		
		// 按行读取数据
		String line = null;
		while((line = reader.readLine()) != null){
			System.out.println(line);
		}
		
		// 关流---从里向外依次关闭
		// Stream Already closed.
		reader.close();
	}
	
}

四、字节流

  • 可以用字节流来读取任意文件  ，如： 视频 、音频

五、转换流

  • 将字节转换为字符示例： 
    public class InputStreamReaderDemo {

	public static void main(String[] args) throws Exception {

		// 实际上读取数据的FileInputStream,转换流将字节转化为字符
		InputStreamReader ir = new InputStreamReader(new FileInputStream("E:\\d.txt"), "utf-8");

		// 数据是以字符形式来返回的
		char[] cs = new char[4];
		int len = -1;
		while ((len = ir.read(cs)) != -1) {
			System.out.println(new String(cs, 0, len));
		}

		ir.close();
	}

}

  • 将字符转换为字节示例：
    public class OutputStreamWriterDemo {

	public static void main(String[] args) throws Exception {

		// 在底层实际上传输数据的是FileOutputStream,转换流提供的操作是将字符转化为字节
		// 当没有指定转换编码的时候，默认使用的是系统平台码
		OutputStreamWriter ow = new OutputStreamWriter(new FileOutputStream("E:\\d.txt"), "utf-8");

		// 写出数据
		ow.write("转换");

		// 关流
		ow.close();
	}

}

  • 练习： 改变文件的编码
    public class ChangeEncodeExer {

	public static void main(String[] args) throws Exception {

		// 创建一个file对象指向源文件
		File file = new File("F:\\java基础增强.txt");

		// 创建一个file对象指向临时文件
		File temp = new File("F:\\temp.txt");

		// 创建一个输入流来读取源文件
		BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file), "utf-8"));

		// 创建一个输出流将读取的内容写到临时文件中
		// BufferedWriter bw = new BufferedWriter(new FileWriter(temp));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(temp)));

		// 定义一个变量来记录读取的每行数据
		String msg = null;

		// 读取数据
		while ((msg = br.readLine()) != null) {
			// 将读取到的数据写出
			bw.write(msg);
			// 换行
			bw.newLine();
		}

		// 关流
		br.close();
		bw.close();

		// 删除源文件
		file.delete();

		// 重命名新文件
		temp.renameTo(file);

	}

}

六、系统流\标准流

  • 系统流示例：
    public class SystemDemo {

	public static void main(String[] args) throws Exception {

		// 系统流都是字节流

		int i = System.in.read();

		// 在使用的时候没有任何差别，只是在输出结果上有颜色的差别
		// 如果是正常的结果使用out来输出打印，如果是错误的结果会使用err来输出打印
		System.out.println(i);
		System.err.println(i);
		System.out.println(new char[]{'a','d'});
		System.out.println(new int[]{'a','d'});

	}

}

  • 练习： 从控制台读取内容后输出
    public class GetLineExer {

	public static void main(String[] args) throws Exception {

		// 从控制台获取---System.in
		// 获取一行数据---BufferedReader
		// System.in是一个字节，BufferedReader需要一个字符流---字节转化成字符---InputStreamReader
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.println(br.readLine());

		br.close();

		// br = new BufferedReader(new InputStreamReader(System.in));
		// System.out.println(br.readLine());
		// br.close();

	}

}

七、打印流


八、 合并流

  • 示例：
    public class SequenceInputStreamDemo {

	public static void main(String[] args) throws Exception {

		// 创建输入流分别对应的文件
		FileInputStream in1 = new FileInputStream("E:\\a.txt");
		FileInputStream in2 = new FileInputStream("E:\\c.txt");
		FileInputStream in3 = new FileInputStream("E:\\d.txt");

		// 创建一个Vector集合
		Vector<InputStream> vec = new Vector<InputStream>();
		vec.add(in1);
		vec.add(in2);
		vec.add(in3);

		// 转化为一个Enumeration
		Enumeration<InputStream> e = vec.elements();

		// 创建合并流对象
		SequenceInputStream sis = new SequenceInputStream(e);

		// 读取数据
		byte[] bs = new byte[10];
		int len = -1;

		// 在合并的时候没有办法控制文件的编码
		while ((len = sis.read(bs)) != -1) {
			System.out.println(new String(bs, 0, len));
		}

		// 关流
		sis.close();
	}

}

九、序列化流\反序列化流

  • 示例：
    public class Person implements Serializable {

	// 版本号---用版本号来标识一个类。
	// 当一个对象反序列化回来的时候,会自动的比较对象中的版本号和当前类中的版本号是否一致、
	// 如果一致Java才认为这个对象是本类的对象，才允许反序列化
	// 如果没有手动指定版本号，JVM在编译的时候会根据当前类中的方法和属性自动计算一个版本号
	// private static final long serialVersionUID = 329L;

	private static final long serialVersionUID = 6920415629894220824L;

	private String name;
	private int age;
	private char gender;
	private double heigh;
	// 被transient修饰的属性不能被序列化
	private transient double weight;

	public double getHeigh() {
		return heigh;
	}

	public void setHeigh(double heigh) {
		this.heigh = heigh;
	}

	public char getGender() {
		return gender;
	}

	public void setGender(char gender) {
		this.gender = gender;
	}

	public double getWeight() {
		return weight;
	}

	public void setWeight(double weight) {
		this.weight = weight;
	}

	// public static boolean alive;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

}



public class SerialDemo {

	public static void main(String[] args) throws Exception {

		// 准备要序列化的对象
		Person p = new Person();
		p.setName("酸菜鱼");
		p.setAge(16);
		p.setWeight(190);
		// p.alive = true;

		// 创建一个用于序列化的流
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\p.data"));

		// 将对象序列化出去
		oos.writeObject(p);

		// 关流
		oos.close();
	}

}



public class DeserialDemo {

	public static void main(String[] args) throws Exception {

		// 创建反序列化流
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\p.data"));

		// 反序列化对象
		Person p = (Person) ois.readObject();

		// 关流
		ois.close();

		System.out.println(p.getName());
		System.out.println(p.getAge());
		// 如果一个属性没有序列化出去，那么反序列化回来的时候会给这个属性一个默认值
		System.out.println(p.getWeight());
	}

}

  • 序列化加密示例：
    public class 加密例子 {
	
	Key key;

	public void serial(Person p) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
			IllegalBlockSizeException, IOException {

		// 需要找制作钥匙的对象
		// 在此的规则指的加密算法---对称加密，非对称加密
		KeyGenerator generator = KeyGenerator.getInstance("DESede");

		// 产生钥匙
		key = generator.generateKey();

		// 产生锁
		Cipher cipher = Cipher.getInstance("DESede");

		// 将锁和钥匙配对
		// 第一个参数表示钥匙和锁的配对模式
		cipher.init(Cipher.ENCRYPT_MODE, key);

		// 找盒子
		SealedObject so = new SealedObject(p, cipher);

		// 将盒子序列化出去
		ObjectOutputStream ois = new ObjectOutputStream(new FileOutputStream("p.data"));
		ois.writeObject(so);
		ois.close();
	}
	
	public Person deSerial() throws FileNotFoundException, IOException, ClassNotFoundException, InvalidKeyException, NoSuchAlgorithmException{
		
		// 创建反序列化流
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("p.data"));
		
		// 反序列化盒子
		SealedObject so = (SealedObject) ois.readObject();
		
		// 关流
		ois.close();
		
		// 将对象从盒子中取出
		return (Person) so.getObject(key);
	}
	
	public static void main(String[] args) throws Exception {
		
		加密例子 demo = new 加密例子();
		
		Person p = new Person();
		p.setName("张三疯");
		p.setAge(500);
		p.setGender('男');
		
		demo.serial(p);
	}

}

十、 Properties

  • 示例：
    public class PropertiesDemo1 {
	
	public static void main(String[] args) throws Exception {
		
		// 创建properties对象
		Properties prop = new Properties();
		
		// 添加键值对
		prop.setProperty("key", "value");
		prop.setProperty("second", "value");
		
		// 持久化这个映射---必须存储到properties文件中
		// 第二个参数表示给properties文件添加一个注释---用于解释当前properties文件的作用
		prop.store(new FileOutputStream("c.properties"), "this is a demo .");
		
	}

}


  • public class PropertiesDemo2 {

	public static void main(String[] args) throws Exception {

		Properties prop = new Properties();

		// 反序列化
		prop.load(new FileInputStream("c.properties"));

		System.out.println(prop.getProperty("key"));
		System.out.println(prop.getProperty("second","ok"));
		// 如果键不存在，则返回一个null
		// 如果键不存在，则返回指定的值---第二个参数
		System.out.println(prop.getProperty("键", "non"));

	}

}


    

    

    

    

 

 

十一、 枚举
 

 

  • 示例1：
    public class EnumDemo {

	@SuppressWarnings("unused")
	public static void main(String[] args) {

		Season s = Season.Autumn;

	}

}

class Season {

	// 不允许在类外随意创建对象
	private Season() {
	}

	static final Season Spring = new Season();
	static final Season Summer = new Season();
	static final Season Autumn = new Season();
	static final Season Winter = new Season();

}

     
  • 示例2：
    public class EnumDemo2 {

	public static void main(String[] args) {

		Level l = Level.B;
		// l.print();
		
		switch (l) {
		case A:
			System.out.println("ok");
			break;
		case B:
			System.out.println("B~~~");
			break;
		default:
			break;
		}

	}

}

enum Level {
	// 默认构造函数是私有的而且只能是私有的
	// 每个枚举常量之间用 , 隔开，最后一个枚举常量之后最好加上 ; 表示结束
	// public static final Level A = new Level();
	// 枚举常量必须定义在枚举类的首行
	A(90) {
		@Override
		public void print() {
			System.out.println("优秀");
		}
	},
	B(80) {
		@Override
		public void print() {
			System.out.println("良好");
		}
	},
	C(70) {
		@Override
		public void print() {
			System.out.println("中等");
		}
	},
	D(60) {
		@Override
		public void print() {
			System.out.println("及格");
		}
	},
	E(0) {
		@Override
		public void print() {
			System.out.println("不及格");
		}
	};

	private Level(double score) {
		this.score = score;
	}

	private Level() {
	}

	private double score;

	public static double average;

	public double getScore() {
		return score;
	}

	public static void set(double sum) {
		System.out.println(sum / average);
	}

	public void setScore(double score) {
		this.score = score;
	}

	public abstract void print();

}

     
 


                

        

        

    

  


    


                



	

		

			

				
					
JavaDay16:枚举，Properties，三层架构

				
			

			

				

					m0_49553291的博客
				

				

					08-10
					
					344
					
				

			

		

		

			
				
枚举，Properties，三层架构枚举定义固定数量的对象枚举的定义switch caseProperties读取properties内容写Properties内容案例三层架构
枚举
定义固定数量的对象
public class TraLightColor {
	
public static TraLightColor  red = new TraLightColor();
public static TraLightColor  green = new TraLightColor();
public st

			
		

	



                

            
              



	

		

			

				
					
IO流——属性集Properties、枚举

				
			

			

				

					vlucky_long的博客
				

				

					09-17
					
					362
					
				

			

		

		

			
				
1、属性集Properties
1.1、概述
【HashMap和Hashtable 都是通过key=value的方式来存储数据的，它俩的区别：Hashtable不能把null作为key和value】
java.util.Properties继承自Hashtable，来表示一个持久的属性集。它使用键值对结构存储数据，每个键及其对应值都是一个字符串。该类是一个非常实用的类，比如：在后续的开发中，获取数据库连接对象，获取一些配置文件信息等
创建属性文件
属性文件一般放置在src根目录下，属性文件的后缀名.prop

			
		

	



              


  
              

                


	

		

			

				
					
java 枚举遍历键值对 属性类Properties 类加载器

				
			

			

				

					12-26
				

			

		

		

			
				
java 枚举遍历键值对 属性类Properties 类加载器

			
		

	





	

		

			

				
					
小汤学编程之JAVA基础day15——枚举、注解和Properties

				
			

			

				

					SoupTC的博客
				

				

					11-14
					
					291
					
				

			

		

		

			
				
一、枚举
1.枚举的来由     2.枚举的作用     3.枚举的特点     4.扩展：switch里可以传入哪些类型的值
二、注解
1.作用     2.注解的种类     3.自定义注解     4.通过反射读取并使用注解     5.注解参数的类型
三、Properties
1.什么是pr.

			
		

	



		

			
		



	

		

			

				
					
java IO之 序列流  集合对象Properties 打印流  流对象

				
			

			

				

					YiGE_snail的专栏
				

				

					03-30
					
					120
					
				

			

		

		

			
				
序列流
也称为合并流。
SequenceInputStream
　　序列流，对多个流进行合并。
　　SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从
　第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达
包含的最后一个输入流的文件末尾为止。
　　注意：
　　构造函数
　　SequenceInputStream(Inp...

			
		

	





	

		

			

				
					
JAVA基础_Java IO流 控制台到记事本、记事本到控制台及详解

				
			

			

				

					Hakey的博客
				

				

					07-19
					
					3173
					
				

			

		

		

			
				
1. 从记事本读数据import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamRea

			
		

	





	

		

			

				
					
java IO流(properties)

				
			

			

				

					qq_29817411的博客
				

				

					08-10
					
					455
					
				

			

		

		

			
				
/*
 * 1.Properties是hashtable的子类:
 * 他具备map集合的特点，而且它里面存储的键值对都是字符串。
 * 是集合中和IO技术相结合的集合容器。
 * 该对象的特点：可以用于键值对形式的配置文件，操作硬盘上的键值对。
 * 
 * 2.将流中的数据存储到集合中（load方法原理）:
 * 用一个流和info.txt文件关联。
 * 读取一行数据，将改行

			
		

	





	

		

			

				
					
swagger返回枚举_java – 使用外部枚举定义从JAX-RS端点生成Swagger

				
			

			

				

					weixin_31876345的博客
				

				

					01-30
					
					418
					
				

			

		

		

			
				
Am I doing something wrong or is it a ‘feature’ of the swagger-jaxrslibrary ?枚举值通过swagger处理为原始值类型,并且开箱即用不会为枚举类型(see code第209行)生成模型定义.所以这是一个功能,与swagger-jaxrs无关.但是,通过提供自定义模型转换器(io.swagger.converter.Mode...

			
		

	





	

		

			

				
					
java--IO流-Properties类

				
			

			

				

					Navan
				

				

					04-01
					
					360
					
				

			

		

		

			
				
Properties是hashtable的子类。是个Map集合
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
那么在加载数据时，需要数据有固定格式：键=值。
Properties，该类主要用于读取以项目的配置文件（以.properties结尾的文件和.xml文件）。

prope

			
		

	





	

		

			

				
					
IO流概述及其分类

				
			

			

				

					qq_36760873的博客
				

				

					08-26
					
					594
					
				

			

		

		

			
				
IO流概述及其分类
IO概念
IO流用来处理设备之间的数据传输,Java对数据的操作是通过流的方式
Java用于操作流的类都在IO包中，

流按流向分为两种:
输入流（读取数据）
输出流（写数据）

流按操作类型分为两种:
字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
字符流 : 字符流只能操作纯字符数据，比较方便。

常用的IO流类
字节流的抽象父类
Inpu...

			
		

	





	

		

			

				
					
添加Properties取值和枚举取值

				
			

			

				

					weixin_34023863的博客
				

				

					11-15
					
					943
					
				

			

		

		

			
				
<!--配置文件--><property name="ppp">
<props>
<prop key="11">hello</prop>
<prop key="22">bye</prop>
</props>

</property>
</bean>


　...

			
		

	





	

		

			

				
					
Java遍历Properties的所有的元素，四种方法详细总结的代码实例

					
热门推荐

				
			

			

				

					请叫我大师兄
				

				

					05-03
					
					1万+
					
				

			

		

		

			
				
使用Java代码，详细示范四种遍历Properties中的所有元素，并打印输出的代码实例。

直接看代码吧。具体怎么读的文件，我在这就省略啦。我的前一篇文章就是示范怎么读和写Properties文件的。可以参考下。


    /**
     * 输出properties的key和value
     */
    public static void printProp(Properties ...

			
		

	





	

		

			

				
					
Java——properties类的常见方法及其使用

				
			

			

				

					没有标题
				

				

					10-09
					
					1245
					
				

			

		

		

			
				
properties的概述和作为map的使用
     properties(常用来做配置文件):是一个双列集合，properties类表示了一个持久的属性集，可保存在流中或从流中加载，属性列表中每个键及其对应值都是一个字符串,是Hashtable的子类
        (1)作为Map集合的使用
        (2)其他功能的使用
            public Object setPr...

			
		

	





	

		

			

				
					
黑马程序员_javaIO流

				
			

			

				

					zengpangzp的博客
				

				

					07-21
					
					417
					
				

			

		

		

			
				
按操作数据分为字节流和字符流；
按流向分为输入流和输出流；
字符流基类：
字符输入流(Reader)：读取数据
int read(); 读取一个字符
int read(char[] buffer) 读取字符数组
字节输出流(Writer)：写出数据
void write(int ch) 写入一个字符
void write(char[] buffer) 写入一个字符数组
void 

			
		

	





	

		

			

				
					
java 枚举获取key_java  –  Spring从属性文件中获取枚举值

				
			

			

				

					weixin_34766430的博客
				

				

					01-12
					
					427
					
				

			

		

		

			
				
我经常有类似的用例,我通过将键(不是本地化的值)作为枚举属性来处理.使用ResourceBundle(或使用Spring时的MessageSource),我可以在需要时解析任何此类本地化字符串.这种方法有两个优点：>所有本地化字符串都可以存储在一个.properties文件中,这样可以消除Java类中的所有编码问题;>它使代码完全可本地化(事实上,它将是每个语言环境一个.propert...

			
		

	





	

		

			

				
					
Java双属性枚举使用

				
			

			

				

					Thancks
				

				

					04-25
					
					6011
					
				

			

		

		

			
				
最近有小伙伴问我，双枚举类该怎么写，还得包括根据key取值方法。 于是就手写一个案例如下：


/**
 * 关系类型枚举
 * @author : shijing
 * 2018年4月25日下午5:58:54
 */
public enum RelationType {
	
	MAPPING(0,"映射"),
	QUOTE(1,"引用/授权"),
	ENTRUST(2,"委托"),
	AGENT...

			
		

	





	

		

			

				
					
springboot 中通过配置国际化文件( messages.properties )给枚举类( enum )赋值

				
			

			

				

					一颗小白羊
				

				

					01-16
					
					4533
					
				

			

		

		

			
				
1. 在 application .properties 中配置国际化文件的路径2.  枚举类 Level.java3.  在 messages.properties  中加入测试信息4. 编写测试类5. 运行并输出结果
1. 在 application .properties 中配置国际化文件的路径
spring.messages.basename=i18n/messages

2.  枚举类...

			
		

	





	

		

			

				
					
Java常用API（五）Math 数学类

				
			

			

				

					chou_out_man的博客
				

				

					09-21
					
					4121
					
				

			

		

		

			
				
一、概述


Math是最终类，且构造函数被私有化，所以不允许创建对象。但是提供了一系列的静态方法---完全作为了工具类使用。只提供了初等的运算。
二、常量


E  ：底数 ，是所有自然数的底数。PI ：π  ，圆周率 。
三、方法


ceil() : 向上取整。 返回doouble类型的值。floor() : 向下取整。 返回都变了类型的值。round() : 四舍五入

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值