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 ...
随机推荐
- 织梦文章里面的图片alt和title属性，用文章标题自动替换
把{dede:field.body/}改成{dede:field.body runphp=yes}global $dsql,$id,$aid;$myid = isset($id) ? $id : $a ...
- 冒泡排序（js版）
基本思想:两两比较相邻记录的关键字,如果反序则交换,直至没有反序为止. 最初的冒泡排序(初级版): //从小到大 function BubbleSort(arr){ var i,j,temp; for ...
- IDEA 的主题设置
1.主题设置(Appearance& Behavior) 补充1:设置编辑区的主题 (1)IDEA提供了两个编辑区的主题,如下所示 (2)如果想要更多的主题效果,可以到 http://www. ...
- 如何选择稳定的PHP虚拟主机？
先评估自己的业务量有多大如果是新站且流量和数据量都不大的话,建议刚开始先购买低配的即可,待流量逐渐增大时在逐渐升级,灵活又省钱 带宽的限制 虚拟主机带宽是指同一时间内所能承载的数据的能力,直接关系大虚 ...
- POJ2230 Watchcow
原题链接 类欧拉回路,要求每条边被正反各经过一次,且从\(1\)出发并回到\(1\). 只需每次搜索该点的边时,将该点的边对应的邻接表头及时修改为下一条即可,因为邻接表恰好储存了正反方向的边,所以及时 ...
- 在nginx中,禁止IP访问.只可以使用域名访问.
if ($host ~* "\d+\.\d+\.\d+\.\d+"){ ; } 其实说白了, 就是进行host主机头过滤,使用正则来判断下.
- readv writev示例程序
当 readv() 时候,需要程序自己提供space,接收数据. #include <stdio.h> #include <stdlib.h> #include <str ...
- 论坛：一对一关联映射/单向关联/两个类间，可以有两个（多个）关联关系/content为大文本类型/
>>单向:只写一端的映射属性,另一端不写(有一端用不着);双向:两端都写映射属性 >>一对一关联有两类:一类基于主键的(一般不使用),一类基于外键的(重点学习): 外键:是一个 ...
- 模态框MODAL的一些事件捕捉
下表列出了模态框中要用到事件.这些事件可在函数中当钩子使用. 事件 描述 实例 show.bs.modal 在调用 show 方法后触发. $('#identifier').on('show.bs.m ...
- Wordvec_句子相似度
import jiebafrom jieba import analyseimport numpyimport gensimimport codecsimport pandas as pdimport ...