java基础-day25
第02天 java基础加强
今日内容介绍
u Properties的基本操作
u 反射综合案例
u BeanUtils概述及使用
第1章 Properties的基本操作
1.1 Properties的概述及基本使用
1.1.1 Properties的概述
Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
特点：
1、Map接口的子类，map中的方法都可以用。
2、该集合没有泛型。键值都是字符串。
3、它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。
4、有和流技术相结合的方法。
1.2 常用方法
l public Object setProperty(String key, String value)调用 Map 的方法 put。
l public Set<String> stringPropertyNames()返回此属性列表中的键集，
l public String getProperty(String key)用指定的键在此属性列表中搜索属性
1.2.1 案例代码一
public class PropsDemo_01 {
@Test
public void demo01(){
//Properties对象 特殊Map<String,String>
//1 创建对象
Properties props = new Properties();
//2 设置数据
//props.put(key, value)
props.setProperty("k01", "v01");
props.setProperty("k02", "v02");
props.setProperty("k03", "v03");
//3 获得指定名称的数据
String prop = props.getProperty("k02");
System.out.println(prop);
//4获得所有名称，并遍历获得所有的数据
System.out.println("--------------");
Set<String> names = props.stringPropertyNames();
for(String name : names){
String value = props.getProperty(name);
System.out.println(name + " : " + value);
}
}
}
1.3 Properties加载文件写入文件
1.3.1 将集合中内容存储到文件
l store(OutputStream,commonts)
l stroe(Writer,comments);
把集合中的数据，保存到指定的流所对应的文件中，参数commonts代表对描述信息
1.3.2 案例代码二
@Test
public void demo01() throws Exception{
//将内容写入到文件
// * Properties 对应一种特殊文件：*.properties
// * 一行表示一个键值对，格式：k=v
//1 创建对象
Properties props = new Properties();
//2 设置数据
//props.put(key, value)
props.setProperty("k01", "v01黑马");
props.setProperty("k02", "v02程序员");
props.setProperty("k03", "v03");
//3 将props写入到硬盘
Writer writer = new OutputStreamWriter(new FileOutputStream("1.properties"),"UTF-8");
props.store(writer, "描述");
writer.close();
}
1.3.3 读取文件中的数据，并保存到集合
l load(InputStream)
l load(Reader)
把指定流所对应的文件中的数据，读取出来，保存到Propertie集合中
1.3.4 案例代码三
@Test
public void demo02() throws Exception{
//从properties文件中获得数据
//1 获得资源流
Reader reader = new InputStreamReader(new FileInputStream("1.properties"),"UTF-8");
//2 通过Properties对象加载流
Properties props = new Properties();
props.load(reader);
//3 遍历所有
for(String name : props.stringPropertyNames()){
String value = props.getProperty(name);
System.out.println(name + " @ " + value);
}
}
第2章 反射综合案例
2.1 需求分析
将javaBean的数据以配置文件的方式写进properties中，读取配置文件写进BeanConfig进行封装，在测试类中去读BeanConfig中封装的数据，并以反射的方式根据读取的数据创建对象，给对象的属性设置值。
反射的好处：我们不用将数据写死到java代码中，可以使用配置文件将数据写入配置文件中。提高了代码的灵活性。
2.2
案例代码四
2.2.1 首先编写JavaBean
User类
package com.itheima_02_demo.bean;
public class User {
private String uid;
private String username;
private String password;
public String getUid() {
return uid;
}
public void
setUid(String uid) {
this.uid = uid;
}
public String getUsername() {
return username;
}
public void
setUsername(String username) {
this.username
= username;
}
public String getPassword() {
return password;
}
public void
setPassword(String password) {
this.password
= password;
}
@Override
public String toString() {
return "User
[uid=" + uid + ", username=" + username
+ ", password=" + password + "]";
}
}
Book类
package com.itheima_02_demo.bean;
public class Book {
private String bid;
private String title;
private String price;
public String getBid() {
return bid;
}
public void
setBid(String bid) {
this.bid = bid;
}
public String getTitle() {
return title;
}
public void
setTitle(String title) {
this.title
= title;
}
public String getPrice() {
return price;
}
public void
setPrice(String price) {
this.price
= price;
}
@Override
public String toString() {
return "Book
[bid=" + bid + ", title=" + title
+ ", price=" + price + "]";
}
}
2.2.2 创建配置文件
bean.properties
id=id001
className=com.itheima.domain.User
data.properties
uid=u001
userName=jack
password=1234
2.2.3 编写BeanConfig类
目的: 封装2个Properties文件中的内容
import java.util.Properties;
public class BeanConfig {
private String id;
private String className;
private Properties props
= new Properties();
public String getId() {
return id;
}
public void
setId(String id) {
this.id = id;
}
public String getClassName() {
return className;
}
public void
setClassName(String className) {
this.className
= className;
}
public Properties getProps() {
return props;
}
public void
setProps(Properties props) {
this.props
= props;
}
@Override
public String toString() {
return "BeanConfig
[id=" + id + ", className=" + className + ", props="
+ props + "]";
}
}
2.2.4 解析Properties
public class Demo_02 {
@Test
public void demo01() throws Exception{
//读取配置文件，获得具体信息
BeanConfig beanConfig = new BeanConfig();
//1 读取bean.properties文件，设置id和className属性
Properties beanProps = new Properties();
beanProps.load(new InputStreamReader(new FileInputStream("bean.properties"), "UTF-8"));
beanConfig.setId(beanProps.getProperty("id"));
beanConfig.setClassName(beanProps.getProperty("className"));
//2读取data.properties文件，设置getProps().setProperty()
Properties dataProps = new Properties();
dataProps.load(new InputStreamReader(new FileInputStream("data.properties"), "UTF-8"));
for(String name : dataProps.stringPropertyNames()){
String value = dataProps.getProperty(name);
beanConfig.getProps().setProperty(name, value);
}
System.out.println(beanConfig);
}
}
2.2.5 使用BeanConfig数据
import java.lang.reflect.Method;
import org.junit.Test;
import com.itheima.domain.BeanConfig;
public class Demo_03 {
@Test
public void
demo01() throws Exception{
//模拟数据
BeanConfig
beanConfig = new
BeanConfig();
beanConfig.setId("id001");
beanConfig.setClassName("com.itheima.domain.User");
beanConfig.getProps().setProperty("uid", "u001");
beanConfig.getProps().setProperty("userName", "jack");
beanConfig.getProps().setProperty("password", "1234");
//使用数据创建JavaBean实例，并为JavaBean封装具体数据
//1 创建实例，使用反射
Class
clazz = Class.forName(beanConfig.getClassName());
Object
obj = clazz.newInstance();
//2 调用JavaBean的setter方法进行数据封装
for(String name
: beanConfig.getProps().stringPropertyNames()){
String
value = beanConfig.getProps().getProperty(name);
// 获得方法名称 : set前缀 + 大写首字母
+ 其他内容
String
methodName = "set"
+ name.substring(0, 1).toUpperCase() + name.substring(1);
// 调用setter方法
Method
method = clazz.getMethod(methodName, String.class);
method.invoke(obj,
value);
}
System.out.println(obj);
}
}
2.2.6 综合案例整合
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.util.Properties;
import org.junit.Test;
import com.itheima.domain.BeanConfig;
public class Demo_04 {
//获得配置文件具体数据
public BeanConfig getBean() throws Exception{
//读取配置文件，获得具体信息
BeanConfig
beanConfig = new
BeanConfig();
//1 读取bean.properties文件，设置id和className属性
Properties
beanProps = new
Properties();
beanProps.load(new
InputStreamReader(new
FileInputStream("bean.properties"),
"UTF-8"));
beanConfig.setId(beanProps.getProperty("id"));
beanConfig.setClassName(beanProps.getProperty("className"));
//2读取data.properties文件，设置getProps().setProperty()
Properties
dataProps = new
Properties();
dataProps.load(new
InputStreamReader(new
FileInputStream("data.properties"),
"UTF-8"));
for(String name
: dataProps.stringPropertyNames()){
String
value = dataProps.getProperty(name);
beanConfig.getProps().setProperty(name, value);
}
return beanConfig;
}
@Test
public void
demo01() throws Exception{
//真实具体数据
BeanConfig
beanConfig = getBean();
//使用数据创建JavaBean实例，并为JavaBean封装具体数据
//1 创建实例，使用反射
Class
clazz = Class.forName(beanConfig.getClassName());
Object
obj = clazz.newInstance();
//2 调用JavaBean的setter方法进行数据封装
for(String name
: beanConfig.getProps().stringPropertyNames()){
String
value = beanConfig.getProps().getProperty(name);
// 获得方法名称 : set前缀 + 大写首字母
+ 其他内容
String
methodName = "set"
+ name.substring(0, 1).toUpperCase() + name.substring(1);
// 调用setter方法
Method
method = clazz.getMethod(methodName, String.class);
method.invoke(obj,
value);
}
System.out.println(obj);
}
}
第3章
BeanUtils的概述及使用
3.1 BeanUtils的概述和简单使用
3.1.1 BeanUtils概述
BeanUtils 是 Apache commons组件的成员之一，主要用于简化JavaBean封装数据的操作。它可以给JavaBean封装一个字符串数据，也可以将一个表单提交的所有数据封装到JavaBean中。
3.1.2 需要的jar包
BeanUtils工具常用工具类有两个：BeanUtils、ConvertUtils[WU1] 。BeanUtils用于封装数据，ConvertUtils用于处理类型转换
常用方法：
|
setProperty(Object obj,String name,Object |
设置属性值，如果指定属性不存在，不抛异常 |
|
getProperty(Object obj,String name) |
获得属性值，如果指定属性不存在，抛方法找不到异常 |
3.1.3 案例代码五
使用BeanUtils把数据封装进User对象
import org.apache.commons.beanutils.BeanUtils;
import org.junit.Test;
import com.itheima_01_bean.User;
public class BeanUtilsDemo_01 {
@Test
public void
demo01(){
//模拟向User对象封装数据
User user = new
User();
user.setUid("u001");
user.setUserName("jack");
user.setPassword("1234");
System.out.println(user);
}
@Test
public void
demo02() throws Exception{
/* 实际开发中，需要封装到JavaBean中的数据存放在配置文件
* * 内容：uid=u001 、userName=jack
*
* JavaBean中两个概念：字段Field、属性Property
* * 字段：就是成员变量。
* 例如：private String
userName;
* 字段名称：userName
* * 属性：通过getter或setter方法推敲获得
* 获得方式：省略set或get前缀，首字母小写
* 例如：getUserName --> UserName --> userName
* * 注意：一般情况下，字段名称和属性名称一致的。
*
* * 特殊情况
* private String description; //字段名：description
* public String getDesc(){ //属性名：desc
* return description;
* }
*/
//1 BeanUtils工具类，提供setProperty 给指定属性设置内容 和 getProperty获得指定属性的值
User user = new
User();
System.out.println("封装前：" + user);
// * 封装数据来自配置文件 , 底层其实 user.setUid("u002")
BeanUtils.setProperty(user, "uid",
"u002");
BeanUtils.setProperty(user, "userName",
"rose");
System.out.println("封装后：" + user);
//2 获得属性值
String
userName = BeanUtils.getProperty(user, "userName");
System.out.println(userName);
}
}
User类
import java.util.Arrays;
public class User {
private String uid;
private String userName;
private String password;
private String[] hobbies; //爱好
private int
age;
public String getUid() {
return uid;
}
public void
setUid(String uid) {
this.uid = uid;
}
public String getUserName() {
return userName;
}
public void
setUserName(String userName) {
this.userName
= userName;
}
public String getPassword() {
return password;
}
public void
setPassword(String password) {
this.password
= password;
}
public String[] getHobbies() {
return hobbies;
}
public void
setHobbies(String[] hobbies) {
this.hobbies
= hobbies;
}
public int
getAge() {
return age;
}
public void
setAge(int age)
{
this.age = age;
}
@Override
public String toString() {
return "User
[uid=" + uid + ", userName=" + userName
+ ", password=" + password + ",
hobbies="
+
Arrays.toString(hobbies) + ", age=" + age
+ "]";
}
}
3.2 BeanUtils的populate方法的使用
3.2.1 方法说明
BeanUtils对象 populate(Object bean, Map<String,String[]>
properties) 将Map数据封装到指定Javabean中，一般用于将表单的所有数据封装到javabean。
3.2.2 案例代码六
使用populate方法将数据封装到User对象中
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.beanutils.BeanUtils;
import org.junit.Test;
import com.itheima_01_bean.User;
public class BeanUtilsDemo_02 {
@Test
public void
demo01() throws Exception{
//1.模拟数据，创建一个Map，填充需要的数据
Map<String,String[]>
map = new
HashMap<String,String[]>();
map.put("uid",
new String[]{"u001"});
map.put("userName",
new String[]{"jack","rose"});
map.put("password",
new String[]{"1234"});
//2 将使用populate进行填充
User user = new
User();
BeanUtils.populate(user, map);
System.out.println(user);
}
@Test
public void
demo02() throws Exception{
//1.模拟数据，创建一个Map，填充需要的数据
Map<String,String[]>
map = new
HashMap<String,String[]>();
map.put("uid",
new String[]{"u001"});
map.put("userName",
new String[]{"jack","rose"});
map.put("password",
new String[]{"1234"});
map.put("hobbies",
new String[]{"敲代码","早上敲代码","晚上敲代码"});
map.put("age",
new String[]{"123"});
//2 将使用populate进行填充
// * 可以向指定的属性，填充一组数据。需要类型必须是[]
// * 如果属性不是数组，将使用map.value表示数组中的第一个。
// * BeanUtils支持类型：基本类型 和 基本类型对应的包装类 。自动将字符串转换基本类型
User user = new
User();
BeanUtils.populate(user, map);
System.out.println(user);
}
}
3.3 BeanUtils自定义工具类
3.3.1 自定义工具类的基本使用
3.3.2 案例代码七
1.定义静态的一个工具类，定义方法populate，参数为Object 和 Map<String,String[]>
返回值类型为void
import java.util.Map;
import org.apache.commons.beanutils.BeanUtils;
public class MyBeanUtils {
/**
* 自动填充
* @param bean
* @param properties
*/
public static
void populate(Object bean , Map<String,String[]> properties ){
try {
BeanUtils.populate(bean, properties);
} catch (Exception e)
{
//将编译时异常，转换成运行时，方便调用者(使用者不需要再次处理异常)
throw new
RuntimeException(e);
}
}
}
测试代码
@Test
public void demo01() {
//1.模拟数据，创建一个Map，填充需要的数据
Map<String,String[]> map = new HashMap<String,String[]>();
map.put("uid", new String[]{"u001"});
map.put("userName", new String[]{"jack","rose"});
map.put("password", new String[]{"1234"});
//2 将使用populate进行填充
User user = new User();
MyBeanUtils.populate(user, map);
System.out.println(user);
}
2.定义静态的一个工具类，定义方法populate，参数为Class 和 Map<String,String[]>
返回值类型为Object
/**
* 自动填充
* @param
bean
* @param
properties
*/
public static Object populate(Class beanClass , Map<String,String[]> properties ){
try {
//1 使用反射进行实例化
Object bean = beanClass.newInstance();
//2 填充数据
BeanUtils.populate(bean, properties);
//3 将填充好JavaBean实例返回
return bean;
} catch (Exception e) {
//将编译时异常，转换成运行时，方便调用者(使用者不需要再次处理异常)
throw new RuntimeException(e);
}
}
}
3.3.3 带泛型的自定义工具类
3.3.4 代码案例八
1.定义静态的一个工具类，定义方法populate，参数为Class<T>和 Map<String,String[]>
返回值类型为T
public class MyBeanUtils3 {
/**
* 自动填充
* @param bean
* @param properties
*
* Class<T> 此处的T就是一个变量，在运行时，接收具体类型。例如：User
* 变量必须先定义在使用
* 泛型变量的定义方式：修饰符 <变量名> 返回值
*/
public static
<T> T populate(Class<T> beanClass
, Map<String,String[]> properties ){
try {
//1 使用反射进行实例化
T
bean = beanClass.newInstance();
//2 填充数据
BeanUtils.populate(bean, properties);
//3 将填充好JavaBean实例返回
return bean;
} catch (Exception e)
{
//将编译时异常，转换成运行时，方便调用者(使用者不需要再次处理异常)
throw new
RuntimeException(e);
}
}
}
2.测试类
@Test
public void demo03() throws
Exception{
//工具类使用
Map<String,String[]> properties = new HashMap<String,String[]>();
properties.put("id", new String[]{"18"});
properties.put("username", new String[]{"jack"});
properties.put("pwd", new String[]{"1234"});
User obj = MyBeanUtils.populate2(User.class, properties);
System.out.println(obj);
/* 结果：
* User [id=18, username=jack, pwd=1234]
*/
}
已经删除
java基础-day25的更多相关文章
- Java基础系列--HashMap（JDK1.8）
原创作品,可以转载,但是请标注出处地址:https://www.cnblogs.com/V1haoge/p/10022092.html Java基础系列-HashMap 1.8 概述 HashMap是 ...
- Java基础知识（壹）
写在前面的话 这篇博客,是很早之前自己的学习Java基础知识的,所记录的内容,仅仅是当时学习的一个总结随笔.现在分享出来,希望能帮助大家,如有不足的,希望大家支出. 后续会继续分享基础知识手记.希望能 ...
- [Java面经]干货整理, Java面试题(覆盖Java基础,Java高级,JavaEE,数据库,设计模式等)
如若转载请注明出处: http://www.cnblogs.com/wang-meng/p/5898837.html 谢谢.上一篇发了一个找工作的面经, 找工作不宜, 希望这一篇的内容能够帮助到大 ...
- 【JAVA面试题系列一】面试题总汇--JAVA基础部分
JAVA基础 基础部分的顺序: 基本语法,类相关的语法,内部类的语法,继承相关的语法,异常的语法 线程的语法,集合的语法,io 的语法,虚拟机方面的语法 每天几道,持续更新!! 1.一个". ...
- 最适合作为Java基础面试题之Singleton模式
看似只是最简单的一种设计模式,可细细挖掘,static.synchronized.volatile关键字.内部类.对象克隆.序列化.枚举类型.反射和类加载机制等基础却又不易理解透彻的Java知识纷纷呼 ...
- java基础练习 字符串，控制流，日历，日期等
1,对基本控制流程的一些练习 package org.base.practice3; import org.junit.Test; /** * Created with IntelliJ IDEA. ...
- Java基础知识【下】( 转载)
http://blog.csdn.net/silentbalanceyh/article/details/4608360 (最终还是决定重新写一份Java基础相关的内容,原来因为在写这一个章节的时候没 ...
- Java基础知识【上】(转载)
http://blog.csdn.net/silentbalanceyh/article/details/4608272 (最终还是决定重新写一份Java基础相关的内容,原来因为在写这一个章节的时候没 ...
- java基础学习03（java基础程序设计）
java基础程序设计 一.完成的目标 1. 掌握java中的数据类型划分 2. 8种基本数据类型的使用及数据类型转换 3. 位运算.运算符.表达式 4. 判断.循环语句的使用 5. break和con ...
随机推荐
- python any() all()
any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True. 元素除了是 0.空.FALSE 外都算 TRUE. ...
- memcached 一致性hash原理
memcache 是一个分布式的缓存系统,但是本身没有提供集群功能,在大型应用的情况下容易成为瓶颈.但是客户端这个时候可以自由扩展,分两阶段实现.第一阶段:key 要先根据一定的算法映射到一台memc ...
- MySql数据库 sql查询增加序号的伪列
在查询数据库的时候,我们有时候需要对查询出来的数据加上序列,1,2,3,……n 例如:我们根据表的某个字段排序后,要对这些数据加上序列,这个时候序号常常不是我们建表时设置好的自增的主键id,怎么办呢? ...
- Spring 注解驱动（二）Servlet 3.0 注解驱动在 Spring MVC 中的应用
Spring 注解驱动(二)Servlet 3.0 注解驱动在 Spring MVC 中的应用 Spring 系列目录(https://www.cnblogs.com/binarylei/p/1019 ...
- Silverlight保存大数据到WCF出现Not Found问题
Silveright调用WCF保存大数据时,直接在客户端报“ 远程服务器返回了错误:Not Found ”问题,少量是没问题,如下图: 后面在这个文章中找到解决办法: http://www.cnblo ...
- 2017/2/8 hibernate + oracle 实现id的自增 同时 hibernate项目跑起来 会自己增加字段的原因 oracle触发器的使用
hibernate + oracle 实现id的自增 1.在oracle中先创建一个序列 : 序列语法 如下 create sequence (序列名称)seq_student_id minva ...
- MYSQL索引类型+索引方法
MYSQL索引有四种 PRIMARY(唯一且不能为空:一张表只能有一个主键索引). INDEX(普通索引). UNIQUE(唯一性索引). FULLTEXT(全文索引:用于搜索很长一篇文章的时候,效果 ...
- [C#]RichTextBox实现拖放
amespace WindowsFormsApplication1 { public partial class Form1 : Form { public Form1() { InitializeC ...
- oracle 分组中排序（rank函数）
需求: 查询每个供应商在每个类型产品销售的top50中有多少 分析: 1.查询,以指定字段(供应商.产品类型)分组,取每个分组的前50行,查看每个供应商的数量 2.使用rank函数给每个供应商.每个类 ...
- SQL语句备份和还原数据库
1,使用SQL最简单备份,还原数据库 1 /* 备份 */ 2 backup database Test to disk='D:/Test.bak' 3 /* 还原 */ 4 restore data ...