yxhxj2006

Java对Excel表格的操作

摘要: Java对Excel表格的操作目前软件开发多采用B/S架构。正B/S架构可以给软件的开发部署带来很大的便利，但是与此同时这种架构也带来了一些问题，例如Web报表的处理等，在B/S架构下，客户端的开发并没有丰富的、互动性能良好的界面组件供开发人员调用，而且调用客户端机器上的设备也很不方便。这些缺陷将会导致B/S架构的软件在客户端的一些功能开发陷入困境。 &n... 阅读全文

posted @ 2012-08-09 16:31 奋斗成就男人阅读(7042) | 评论 (1) | 编辑收藏

java中各种数据类型相互转换方法

1如何将字串 String 转换成整数 int?

A. 有两个方法:

1). int i = Integer.parseInt([String]); 或
i = Integer.parseInt([String],[int radix]);

2). int i = Integer.valueOf(my_str).intValue();

注: 字串转成 Double, Float, Long 的方法大同小异.

2 如何将整数 int 转换成字串 String ?

A. 有叁种方法:

1.) String s = String.valueOf(i);

2.) String s = Integer.toString(i);

3.) String s = "" + i;

注: Double, Float, Long 转成字串的方法大同小异.

JAVA数据类型转换       ynniebo [收藏]
关键字     类型转换
出处

这是一个例子,说的是JAVA中数据数型的转换.供大家学习引

package cn.com.lwkj.erts.register;
import java.sql.Date;
public class TypeChange {
    public TypeChange() {
    }
    //change the string type to the int type
    public static    int stringToInt(String intstr)
    {
      Integer integer;
      integer = Integer.valueOf(intstr);
      return integer.intValue();
    }
    //change int type to the string type
    public static String intToString(int value)
    {
      Integer integer = new Integer(value);
      return integer.toString();
    }
    //change the string type to the float type
    public static    float stringToFloat(String floatstr)
    {
      Float floatee;
      floatee = Float.valueOf(floatstr);
      return floatee.floatValue();
    }
    //change the float type to the string type
    public static String floatToString(float value)
    {
      Float floatee = new Float(value);
      return floatee.toString();
    }
    //change the string type to the sqlDate type
    public static java.sql.Date stringToDate(String dateStr)
    {
      return    java.sql.Date.valueOf(dateStr);
    }
    //change the sqlDate type to the string type
    public static String dateToString(java.sql.Date datee)
    {
      return datee.toString();
    }

    public static void main(String[] args)
    {
      java.sql.Date day ;
      day = TypeChange.stringToDate("2003-11-3");
      String strday = TypeChange.dateToString(day);
      System.out.println(strday);
    }

}

JAVA中常用数据类型转换函数
虽然都能在JAVA API中找到，整理一下做个备份。

string->byte
Byte static byte parseByte(String s)

byte->string
Byte static String toString(byte b)

char->string
Character static String to String (char c)

string->Short
Short static Short parseShort(String s)

Short->String
Short static String toString(Short s)

String->Integer
Integer static int parseInt(String s)

Integer->String
Integer static String tostring(int i)

String->Long
Long static long parseLong(String s)

Long->String
Long static String toString(Long i)

String->Float
Float static float parseFloat(String s)

Float->String
Float static String toString(float f)

String->Double
Double static double parseDouble(String s)

Double->String
Double static String toString(Double)

++++++++++++++++++++++++++++++++++++++++++++++++++++++

数据类型
基本类型有以下四种：
int长度数据类型有：byte(8bits)、short(16bits)、int(32bits)、long(64bits)、
float长度数据类型有：单精度（32bits float）、双精度（64bits double）
boolean类型变量的取值有：ture、false
char数据类型有：unicode字符,16位
对应的类类型：Integer、Float、Boolean、Character、Double、Short、Byte、Long

转换原则
从低精度向高精度转换
byte 、short、int、long、float、double、char
注：两个char型运算时，自动转换为int型；当char与别的类型运算时，也会先自动转换为int型的，再做其它类型的自动转换
基本类型向类类型转换
正向转换：通过类包装器来new出一个新的类类型的变量
Integer a= new Integer(2);
反向转换：通过类包装器来转换
int b=a.intValue();
类类型向字符串转换
正向转换：因为每个类都是object类的子类，而所有的object类都有一个toString()函数，所以通过toString()函数来转换即可
反向转换：通过类包装器new出一个新的类类型的变量
eg1: int i=Integer.valueOf(“123”).intValue()
说明：上例是将一个字符串转化成一个Integer对象，然后再调用这个对象的intValue()方法返回其对应的int数值。
eg2: float f=Float.valueOf(“123”).floatValue()
说明：上例是将一个字符串转化成一个Float对象，然后再调用这个对象的floatValue()方法返回其对应的float数值。
eg3: boolean b=Boolean.valueOf(“123”).booleanValue()
说明：上例是将一个字符串转化成一个Boolean对象，然后再调用这个对象的booleanValue()方法返回其对应的boolean数值。
eg4:double d=Double.valueOf(“123”).doubleValue()
说明：上例是将一个字符串转化成一个Double对象，然后再调用这个对象的doubleValue()方法返回其对应的double数值。
eg5: long l=Long.valueOf(“123”).longValue()
说明：上例是将一个字符串转化成一个Long对象，然后再调用这个对象的longValue()方法返回其对应的long数值。
eg6: char=Character.valueOf(“123”).charValue()
说明：上例是将一个字符串转化成一个Character对象，然后再调用这个对象的charValue()方法返回其对应的char数值。
基本类型向字符串的转换
正向转换：
如：int a=12;
String b;b=a+””;
反向转换：
通过类包装器
eg1:int i=Integer.parseInt(“123”)
说明：此方法只能适用于字符串转化成整型变量
eg2: float f=Float.valueOf(“123”).floatValue()
说明：上例是将一个字符串转化成一个Float对象，然后再调用这个对象的floatValue()方法返回其对应的float数值。
eg3: boolean b=Boolean.valueOf(“123”).booleanValue()
说明：上例是将一个字符串转化成一个Boolean对象，然后再调用这个对象的booleanValue()方法返回其对应的boolean数值。
eg4:double d=Double.valueOf(“123”).doubleValue()
说明：上例是将一个字符串转化成一个Double对象，然后再调用这个对象的doubleValue()方法返回其对应的double数值。
eg5: long l=Long.valueOf(“123”).longValue()
说明：上例是将一个字符串转化成一个Long对象，然后再调用这个对象的longValue()方法返回其对应的long数值。
eg6: char=Character.valueOf(“123”).charValue()
说明：上例是将一个字符串转化成一个Character对象，然后再调用这个对象的charValue()方法返回其对应的char数值

posted @ 2012-08-09 16:29 奋斗成就男人阅读(346) | 评论 (0) | 编辑收藏

Linux中常用命令学习总结

前面的章节里对linux的文件的权限做了简单的解释。现在来看看常见的命令，从简单的开始：

1 、切换目录

到/tmp 目录：cd /tmp

到上层目录：cd ..

2 、查看当前目录

pwd

3、创建一个新的文件夹：

mkdir

创建一层目录：

创建多层目录：

4 、删除目录：

rmdir [-p] 如果需要层级删除目录，就需要带上p（只能删除空目录）

5、查询环境变量

echo $PATH 或者$PATH

6、切换用户：

su 用户名

7、移动文件

仔细阅读上面的命令，你会发现mv还可以对文件进行从命名，上面的命令将hellot.txt从a中移动到了b中，并改名为hello1.txt

8、查看文件与目录

ls -a 目录名称：列出目录中所有的文件

ls -al 目录名：列出长字符串，包含文件的一些详细信息

9、文件的复制：

cp [-adfilprsu] 源文件目标文件 //将源文件拷贝到目标文件

cp src1,src2,... des //将多个源文件拷贝到目的文件夹

cp这个命令非常重要，不同的身份执行对命令产生不同的效果，尤其是-a,-p参数，对不同的身份来说，区别非常大。

例1：

使用root执行：

如果我们要将文件的所有的属性复制过来，则要加上参数-a

复制一个目录到另外一个目录 cp -r /src /desc

10 、移除文件或目录

rm [-fir] 文件或目录

-f 强制的意思，忽略不存在的文件，不会出现警告信息

-i互动模式：删除前，会询问是否删除

-r ：递归删除

这里不再演示，记得之前的rmdir吗，只能删除空目录，所以删除非空目录只能使用rm -r

11、文件类容查询

cat

-b:列出行号

-n:列出行号，包括空白行

cat 是一次性将数据显示到屏幕上，如果想一页一页的看怎么办？

使用more命令

more在运行的过程中，你有几个按键可以按：

空格键：代表向下翻一页

Enter:代表向下滚动一行

q:离开more

b：往回翻页

12 、创建文件

touch

touch a.txt 就会在当前目录下创建a.txt

13、查找文件的命令

whereis ,find

whereis [-bmsu] 文件或目录名

-b:二进制文件

-m:只找在说明文件manual路径下的问津

-s:只找source源文件

-u:查找不在上述三个选项中的其他特殊文件

whereis ifconfig

下面看看find命令

find [path] [option] [actioin]

查找/home下面属于gavin的文件

find /home -user gavin

查找系统中不属于任何人的文件

find / -nouser

查找文件名为passwd的这个文件

find / -name passwd

查找文件类型为socket的文件

find / -type s

14、磁盘和目录的容量

df:列出文件系统的整体磁盘使用量

du:评估文件系统的磁盘使用量

15 创建链接文件

ln [-sf] 源文件目标文件

-s :创建软连接，如果不加则是硬连接

-f:如果目标文件存在，则删除后再建

[root@localhost test2]# echo 'good'>a.txt
[root@localhost test2]# ls
a.txt
[root@localhost test2]# ln -s a.txt b
[root@localhost test2]# ls
a.txt b
[root@localhost test2]# ll
total 12
-rw-r--r-- 1 root root 5 Aug 8 01:09 a.txt
lrwxrwxrwx 1 root root 5 Aug 8 01:09 b -> a.txt
[root@localhost test2]# echo 'hello'>>b
[root@localhost test2]# cat b
good
hello
[root@localhost test2]# cat a.txt
good
hello
[root@localhost test2]# ln a.txt c
[root@localhost test2]# ll
total 20
-rw-r--r-- 2 root root 11 Aug 8 01:09 a.txt
lrwxrwxrwx 1 root root 5 Aug 8 01:09 b -> a.txt
-rw-r--r-- 2 root root 11 Aug 8 01:09 c
[root@localhost test2]# echo 'bad'>>c
[root@localhost test2]# cat c
good
hello
bad
[root@localhost test2]# cat a.txt
good
hello
bad
[root@localhost test2]# cat b
good
hello
bad
[root@localhost test2]# rm a.txt
rm: remove regular file `a.txt'? y
[root@localhost test2]# cat b
cat: b: No such file or directory
[root@localhost test2]# cat c
good
hello
bad
[root@localhost test2]#

运行上面的命令行，相信你对ln的使用会非常清楚的。

15、挂载CD

16、文件压缩

tar

-c:创建一个压缩文件

-v:显示压缩过程

-f:给出压缩文件名

-x:解压文件

-t::查看压缩包中又哪些文件

posted @ 2012-08-09 14:59 奋斗成就男人阅读(280) | 评论 (0) | 编辑收藏

Linux文件权限的那些事

linux是一个多用户，多任务的操作系统，对于每一个文件它的属性中都包括：文件所有者(owner)，文件所属组(group)，其他用户(other),还必须具备与这三个角色对应的读，写，执行的权限，如下图：

在tmp目录下面有一个a.txt文件，我们通过ls -l命令可以查看其详细信息：

-：表示普通文件，d:表示目录文件，l:链接文件,b:设备文件中可以供存储的接口设备,c:设备文件中串行端口设备如键盘。

由于最前面是-：所以a.txt是普通文件。

再看 rw-r--r--部分，我们将其分为三组，分别对应文件所有者，文件所属组，其他用户的权限.

其中r代表读取权限，w:代表写权限，x：代表执行权限(这里没出现),-：代表没有某种权限。

那对上面的权限的解释就是：

owner:可以读和写，不能执行

group:可以读取不能写，不能执行

other:可以读取，不能写，不能执行

第一个root代表文件所有者，第二个root代表文件所属组

那么现在我如果想修改文件所有者，文件所属组，文件权限该怎么做，请继续向下阅读：

chgrp:修改用户所属组，chown：修改文件所有者，chmod:修改文件权限

假设我的系统中又一个叫gavin的组(通过/etc/group查看)

如上图，通过chgrp命令将该文件的group修改为了gavin

下面修改其所有者：

修改其权限：

chmod 777 a.txt 这个777代表什么?

在linux中使用数字代表权限：

r:4 w:2 x:1

r-- =4+0+0=4;

rw- =4+2+0=6;

rwx =4+2+1=7

相信写到这里大家都应该明白了吧。

权限对于文件和文件夹的意义是不一样的，

对于文件：

r:代表可以读取文件的内容，w:代表可以修改文件的内容，x:可以执行这个文件

对于文件夹：

r:可以获取文件夹中又哪些文件，w:可以添加和删除文件夹中的内容，x:可以进入文件夹，

如果某个角色对于一个文件夹的权限是rw-;

那么他仅仅可以使用ls获取文件夹中的内容，但是不可以使用cd进入该文件夹。

文件的权限告一段落，现在来看看linux中的那些常见目录中的内容：

/bin 系统有很多放置执行文件的目录，但是/bin比较特殊，因为/bin放置的是在单用户维护模式下还能够被操作的命令，在/bin下面的命令可以被root和一般账户使用，如：cat,chmod,chown,data,mv,mkdir,cp ,bash等常用命令。

/boot 主要放置开机使用到的文件

/dev 在linux系统中任何设备与接口设备都是以文件的形式存在于这个目录当中，你只要访问某个文件就相当于访问该设备

/etc 系统的主要配置文件几乎都在这个文件夹类。

/home 这是系统默认的用户主文件夹

/lib 系统的函数库非常多，二/lib放置的是开机会使用到的函数库

/mnt 如果你想临时挂在一些外部设备（光盘）一般建议放置到这个目录。

/opt 这是给第三方软件放置的目录

/root 系统管理员的主文件夹

/tmp 这是让一般用户或者正在执行的程序放置文件的地方，这个目录是任何人都可以访问的，所以你需要定期清理一下，当然重要数据时不能放到这里来的。

关于文件权限的最后一点就是：文件默认权限umask

现在我们已经知道如何新建或者改变一个目录的属性了，不过你知道当你新建一个新的文件或则目录是，它的默认权限是什么吗？那就是于umask这东西有关了，那么umask是在搞什么呢，基本上，umask就是制定目前用户在新建文件或目录的时候权限的默认值，如果获得或设置umask，方法如下：

#umask 或则 umask -S

(四位数，第一位我们先不管，表示特殊权限，我们从第二位开始看起)

在默认权限上，文件和目录是不一样的，对于一个目录，x权限是非常重要的，而对于一个文件，x权限在默认是不应该有的，因为文件大多是用来存储数据的，所以在linux中，文件的默认权限是666,目录的默认权限是777

要注意的是umask的分数指的是“默认值需要剪掉的权限”,

所以新建文件时权限：rw--r--r--

新建目录：r-xr-xr-x

posted @ 2012-08-09 14:59 奋斗成就男人阅读(132) | 评论 (0) | 编辑收藏

junit浅学笔记二

上一节初步介绍了什么是单元测试，为什么要做单元测试，以及junit4的初步使用，这里我们接着说一下junit4中的注解。

=============本节知识点============================

* Error和Failures

* Junit4 Annotation

==================================================================

1. 在讲注解之前，先来认识 Error和Failures这两种错误有什么不同。

Errors：表示程序本身错误

@Test
    publicvoid testAdd() {
        int z=new T().add(5,3);
        assertEquals(8,z);
        int a=8/0;  //这一句是有错误的
    }

运行方法，会有一下错误提示：

Failures: 是指测试失败。

@Test
    publicvoid testAdd() {
        int z=new T().add(5,4); //这里修改了数值，把4该为3就正确了 
        assertEquals(8,z);
    }

在来运行这个方法，看一下错误提示：

所以，我们在写测试程序的时候，要先保证Errors是没有错误的，再来看Failures有没有错误。

2. 下面介绍junit4 的常用注解

-----------------------------------------------------------------------------------------------

* @ Test：测试方法

A) (expected=XXEception.class)

B) (timeout=xxx)

*. @ Ignore: 被忽略的测试方法

*. @Before: 每一个测试方法之前云行。

*. @After : 每一个测试方法之后运行。

*. @BefreClass 所有测试开始之前运行。

*. @AfterClass 所有测试结果之后运行。

------------------------------------------------------------------------------------------------

下面通过一个测试程序来解释这些注解含义

package com.junit4.cc.test;

importstatic org.junit.Assert.*;
importstatic org.hamcrest.Matcher.*;

import org.junit.Test;
import com.junit4.cc.*;

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.AfterClass;
import org.junit.After;
import org.junit.Ignore;


publicclass TTest {
    
    @BeforeClass  //的所有方法运行之前运行。
publicstaticvoid beforeClass(){
        System.out.println("------------beforeClass");
    }
    
    @AfterClass   //在所有方法运行之后运行
publicstaticvoid afterClass(){
        System.out.println("-------------afterClass");
    }
    
    @Before   //每个测试方法运行之前运行
publicvoid before(){
        System.out.println("=======before");
    }
    
    @After   //每个测试方法运行之后运行
publicvoid after(){
        System.out.println("=======after");
    }

    @Test
    publicvoid testAdd() {
        int z=new T().add(5,3);
        assertEquals(8,z);
        System.out.println("test Run through");
    }
    
    @Test ()
    publicvoid testdivision(){
              System.out.println("in Test Division");

    }

    @Ignore   //表示这个方法是不被运行的
    @Test
    (expected=java.lang.ArithmeticException.class,timeout=100) //timeout表示要求方法在100毫秒内运行完成，否则报错
publicvoid testDivide(){
        int z =new T().divide(8,2);
    }
    
    

}

运行结果如下：

标记红星（*）方法在每个方法开始和结尾都运行一次。

标记绿星（*）的方法只在所有方法的开始和结尾运行一次。

junit有多种注解，我们常用的也就上面几种。

posted @ 2012-08-09 14:25 奋斗成就男人阅读(142) | 评论 (0) | 编辑收藏

junit浅学笔记三

这一节我们将学习进行批量处理，假如我们有多的测试，怎样进行批量处理，请跟着我做。

---------------------------------------------

假如我们写了两个被测程序。如下：

T.java

package com.junit4.cc;

publicclass T {
    publicint add(int x ,int y){
        return x+y;
    }
    publicstaticvoid main(String args[]){
        int z=new T().add(3,5);
        System.out.println(z);
    }
}

User.java

package com.junit4.cc;

publicclass User {
    public String geName(){
        return"刘若英";   //PS：她是我的偶像嘻嘻：)
    }
}

------------------------------------测试类-------------------------

下面要对上面的两个类写测试类。（关于测试类的创建的方法，不懂的可以看我的第一篇《junit浅学笔记一》）

TTest.java 对应的是T.java的测试类。

package com.junit4.cc.test;

importstatic org.junit.Assert.*;

import org.junit.Test;
import com.junit4.cc.*;

publicclass TTest {
    @Test
    publicvoid testAdd() {
        int z=new T().add(5,3);
        assertEquals(8,z);
    }
}

UserTest.java 对应的是User.java

package com.junit4.cc.test;

importstatic org.junit.Assert.*;

import org.junit.Test;
import com.junit4.cc.User;

publicclass UserTest {

    @Test
    publicvoid testGeName() {
        assertEquals(new User().geName(),("刘若英"));
    }
}

完成之后的列表如下：

要批量运行上面两个测试类，有两个方法。

方法一

右键点击测试包“com.junit4.cc.test”--->Run As--->Run Configurations.

这种方式设置简单，但灵活度不高，假如有100个测试类。我只想运行其中的某几个测试类。下面看第二中方式。

方法二

方法引入一种“测试套件”的概念，JUnit提供了一种批量运行测试类的方法，叫测试套件。

测试套件的写法需要遵循以下原则：

1. 创建一个空类作为测试套件的入口；

2. 使用注解 org.junit.runner.RunWith 和 org.junit.runners.Suite.SuitClasses 修饰这个空类

3. 将org.junit.runners.Suite作为参数传入给注解RunWith，以提示Junit为此类测试使用套件运行器执行。

4. 将需要放入此测试套件的测试类组成数组作为注解SuiteClasses的参数

5. 保证这个空类使用public修饰，而且存在公开的不带任何参数的构造函数

下面在测试包（com.junit4.cc.test）下面创建一个测试类，内容如下：

AllTest.java

package com.junit4.cc.test;


import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
@RunWith(Suite.class)
@SuiteClasses({
 TTest.class,
 UserTest.class  //这里自由加入需要运行的测试类
  })
publicclass AllTest {

}

创建之后的列表：

运行AllTest.java的结果（这里，两个方法的运行结果是一样的）：

ps:关于两种方式的比较，第一种方法简单，只用选择测试包，就可以批量运行里面的所有测试程序。第二种方式还有重新创建一个测试类，但它非常灵活，只用在这个类中加入需要运行的类就可以灵活的运行需要测试的类。

posted @ 2012-08-09 14:24 奋斗成就男人阅读(193) | 评论 (0) | 编辑收藏

junit浅学笔记一

JUnit是一个回归测试框架（regression testing framework）。Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何（How）完成功能和完成什么样（What）的功能。Junit是一套框架，继承TestCase类，就可以用Junit进行自动测试了。

虽然大多情况下他是程序员的活，但作为测试人员还是有必要了解一下，毕竟也是测试工作，提高自己人技术，扩展思想是主要，边学边做笔记，这样学过的东西才不会忘记，嘻嘻~！

========学习环境=================

java编辑器: Eclipse SDK 3.5.6

junit测试包：Eclipse中自带了junit 4 测试包

=================================

1.我们打开eclipse 创建一个工程名字为：Junit4，

创建一个包，命名为：com.junit4.cc ,

包下面创建一个类 T

代码如下：

package com.junit4.cc;

publicclass T {
    publicint add(int x ,int y){
        return x+y;
    }

}

我们如何来做测试，当然了，上面的代码一眼就可以看出结果，需要测试么，我们这里只是想说明问题，如果我们不用测试框架，我们会用写一个main方法对上面的代码进行验证。全部代码如下。

package com.junit4.cc;

publicclass T {
    publicint add(int x ,int y){
        return x+y;
    }
    publicstaticvoid main(String args[]){
        int z=new T().add(3,5); //向T类传递两个参数3和5
        System.out.println(z);  //打印z进行查看3和5是否做了加法运算
    }
}

云行上面的代码，通过查看结果来判断add方法是否正确。

---------------------------------------------------------------------------

上面的单元测试有很多弊端：

@ 需要花费很多的时间来写测试代码

@ 测试代码不可重用，一段测试代码对应一段被测代码。被测代码变，测试代码就没用了

@ 无法同时运行多个测试代码。假如有一百个被测试代码，要一个一个的运行测试代码，用肉眼观察结果，效率低还容易出错。

这是我简单总结的几个缺点。

---------------------------------------------------------------------------

2. 那么我们就要使用单元测试框架来提交效率。

下面我们就使用eclipse来创建一个测试。还是测试上面的代码为例子。

为了查看更加清晰，我们一般将测试代码与被测试的代码放在不同的包下面。

我们在Junit工程下面重新创建一个包，命名为：com.junit4.cc.test

----------------------------

创建一个测试类：TTest

注意：这里要创建的是一个测试类：在com.junit4.cc.test包上面右键点击-->new-->Junit test Case

点击“Next”会让你选择要测试的方法，选择后点击“Finish”则完成创建。

创建完成如下图：

TTest.java代码如下：

package com.junit4.cc.test;

importstatic org.junit.Assert.*;

import org.junit.Test;
import com.junit4.cc.*;

publicclass TTest {

    @Test
    publicvoid testAdd() {
        int z=new T().add(5,3);
        assertEquals(8,z);
    }

}

3. 如果我们想要真正运行TTest.java这个测试类，还要对这个工程引入junit测试包。

右键点击工程（junit4）--->Properties

点击“next ” 按钮，celipse提供junit3和junit4两个测试包，我们选择junit4 点击“finish”就将测试包引入。

4. 下面来运行我们TTest.java测试代码。

看到我们左侧的绿色滚动条，说明我们的被代码是没有问题。

你可以试着修改下面代码的参数：

int z=new T().add(5,3);
assertEquals(8,z); //将5、3、8等数字任意修改，查看绿色滚动条的颜色，给出的提示是什么？

posted @ 2012-08-09 14:23 奋斗成就男人阅读(141) | 评论 (0) | 编辑收藏