java项目编译跳过test目录_怎么在cmd里面运行 java

㈠ java File类删除文件

1、创建File对象File（String pathname）：pathname录入时录入的路径字符串需要注意/和的运用，但是由于java开发出的程序需要运用到不同的系统上，因此，一般以File.separator来代替。

㈡什么是Java虚拟机

虚拟机是一种抽象化的计算机，通过在实际的计算机上仿真模拟各种计算机功能来实现的。

Java虚拟机有自己完善的硬体架构，如处理器、堆栈、寄存器等，还具有相应的指令系统。JVM屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。

这种解释应该算是正确的，但是只描述了虚拟机的外部行为和功能，并没有针对内部原理做出说明。一般情况下我们不需要知道虚拟机的运行原理，只要专注写java代码就可以了，这也正是虚拟机之所以存在的原因--屏蔽底层操作系统平台的不同并且减少基于原生语言开发的复杂性，使java这门语言能够跨各种平台（只要虚拟机厂商在特定平台上实现了虚拟机），并且简单易用。这些都是虚拟机的外部特性，但是从这些信息来解释虚拟机，未免太笼统了，无法让我们知道内部原理。

从进程的角度解释JVM

让我们尝试从操作系统的层面来理解虚拟机。我们知道，虚拟机是运行在操作系统之中的，那么什么东西才能在操作系统中运行呢？当然是进程，因为进程是操作系统中的执行单位。可以这样理解，当它在运行的时候，它就是一个操作系统中的进程实例，当它没有在运行时（作为可执行文件存放于文件系统中），可以把它叫做程序。

对命令行比较熟悉的同学，都知道其实一个命令对应一个可执行的二进制文件，当敲下这个命令并且回车后，就会创建一个进程，加载对应的可执行文件到进程的地址空间中，并且执行其中的指令。下面对比C语言和Java语言的HelloWorld程序来说明问题。

首先编写C语言版的HelloWorld程序。

总结

写到这里，基本上关于我对java虚拟机的理解就写完了。这篇文章的主题虽然是深入理解Java虚拟机，但是你可能感觉一点也不“深入”，也只是泛泛而谈。我也有这样的感觉。限于自己水平有限，也只能这样了，要是想深入理解java虚拟机，强烈建议读一下三本书：

《深入Java虚拟机》

《深入理解Java虚拟机JVM高级特性与最佳实践》

《Java虚拟机规范》

其实我也读过这几本书，但是它们对虚拟机的解释也是基于一个外部模型，而没有深入剖析虚拟机内部的实现原理。虚拟机是一个大而复杂的东西，实现虚拟机的人都是大牛级别的，如果不是参与过虚拟机的实现，应该很少有人能把它参透。本专栏后面的一些文章也参考了这三本书，虽然讲解Java语法的书不计其数，但是深入讲解虚拟机的书，目前为止我就见过这三本，并且网上的资料也不是很多。

最后做一个总结：

1 虚拟机并不神秘，在操作系统的角度看来，它只是一个普通进程。

2 这个叫做虚拟机的进程比较特殊，它能够加载我们编写的class文件。如果把JVM比作一个人，那么class文件就是我们吃的食物。

3 加载class文件的是一个叫做类加载器的子系统。就好比我们的嘴巴，把食物吃到肚子里。

4 虚拟机中的执行引擎用来执行class文件中的字节码指令。就好比我们的肠胃，对吃进去的食物进行消化。

5 虚拟机在执行过程中，要分配内存创建对象。当这些对象过时无用了，必须要自动清理这些无用的对象。清理对象回收内存的任务由垃圾收集器负责。就好比人吃进去的食物，在消化之后，必须把废物排出体外，腾出空间可以在下次饿的时候吃饭并消化食物。

(2)java项目编译跳过test目录扩展阅读：

关于JAVA虚拟机的参数说明如下：

1、运行class文件

执行带main方法的class文件，Java虚拟机[3]命令参数行为：

java <CLASS文件名>

注意：CLASS文件名不要带文件后缀.class

例如：

java Test

如果执行的class文件是带包的，即在类文件中使用了：

package <；包名>

那应该在包的基路径下执行，Java虚拟机命令行参数：

java <；包名>.CLASS文件名

例如：

PackageTest.java中，其包名为：com.ee2ee.test，对应的语句为：

package com.ee2ee.test;

PackageTest.java及编译后的class文件PackageTest.class的存放目录如下：

classes

|__com

|__ee2ee

|__test

|__PackageTest.java

|__PackageTest.class

要运行PackageTest.class，应在classes目录下执行：

java com.ee2ee.test.PackageTest

2、运行jar文件中的class

原理和运行class文件一样，只需加上参数-cp <jar文件名>；即可。

例如：执行test.jar中的类com.ee2ee.test.PackageTest，命令行如下：

java -cp test.jar com.ee2ee.test.PackageTest

3、显示JDK版本信息

当一台机器上有多个jdk版本时，需要知道当前使用的是那个版本的jdk，使用参数-version即可知道其版本，命令行为：

java -version

4、增加虚拟机可以使用的最大内存

Java虚拟机可使用的最大内存是有限制的，缺省值通常为64MB或128MB。

如果一个应用程序为了提高性能而把数据加载内存中而占用较大的内存，比如超过了默认的最大值128MB，需要加大java虚拟机可使用的最大内存，否则会出现Out of Memory的异常。启动java时，需要使用如下两个参数：

-Xms java虚拟机初始化时使用的内存大小

-Xmx java虚拟机可以使用的最大内存

以上两个命令行参数中设置的size，可以带单位，例如：256m表示256MB

举例说明：

java -Xms128m -Xmx256m ...

表示Java虚拟机初始化时使用的内存为128MB，可使用的最大内存为256MB。

对于tomcat，可以修改其脚本catalina. sh（Unix平台）或catalina.bat（Windows平台），设置变量JAVA_OPTS即可，例如：

JAVA_OPTS='-Xms128m -Xmx256m'

㈢如何让maven跳过某些指定的Test用例

<properties>
<maven.test.skip>true</maven.test.skip>
<maven.test.failure.ignore>true</maven.test.failure.ignore>
</properties>

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<skip>${maven.test.skip}</skip>
<testFailureIgnore>${maven.test.failure.ignore}</testFailureIgnore>
</configuration>
</plugin>

㈣ java io缁忓吀浠ｇ爜

package IO;

import java.io.*;

public class FileDirectoryDemo {
public static void main(String[] args) {
// 濡傛灉娌℃湁鎸囧畾鍙傛暟锛屽垯缂虹渷涓哄綋鍓岖洰褰曘
if (args.length == 0) {
args = new String[] { "." };
}
try {
// 鏂板缓鎸囧畾鐩褰旷殑File瀵硅薄銆
File currentPath = new File(args[0]);
// 鍦ㄦ寚瀹氱洰褰曟柊寤篓emp鐩褰旷殑File瀵硅薄銆
File tempPath = new File(currentPath, "temp");
// 鐢ㄢ渢empPath钬濆硅薄鍦ㄦ寚瀹氱洰褰曚笅鍒涘缓temp鐩褰曘
tempPath.mkdir();
// 鍦╰emp鐩褰曚笅鍒涘缓涓や釜鏂囦欢銆
File temp1 = new File(tempPath, "temp1.txt");
temp1.createNewFile();
File temp2 = new File(tempPath, "temp2.txt");
temp2.createNewFile();

// 阃掑綊鏄剧ず鎸囧畾鐩褰旷殑鍐呭广
System.out.println("鏄剧ず鎸囧畾鐩褰旷殑鍐呭");
listSubDir(currentPath);

// 镟存敼鏂囦欢钖嵝渢emp1.txt钬濅负钬渢emp.txt钬濄
File temp1new = new File(tempPath, "temp.txt");
temp1.renameTo(temp1new);
// 阃掑綊鏄剧ずtemp瀛愮洰褰旷殑鍐呭广
System.out.println("镟存敼鏂囦欢钖嶅悗锛屾樉绀篓emp瀛愮洰褰旷殑鍐呭");
listSubDir(tempPath);

// 鍒犻櫎鏂囦欢钬渢emp2.txt钬濄
temp2.delete();
// 阃掑綊鏄剧ずtemp瀛愮洰褰旷殑鍐呭广
System.out.println("鍒犻櫎鏂囦欢钖庯纴鏄剧ずtemp瀛愮洰褰旷殑鍐呭");
listSubDir(tempPath);
} catch (IOException e) {
System.err.println("IOException");
}
}

// 阃掑綊鏄剧ず鎸囧畾鐩褰旷殑鍐呭广
static void listSubDir(File currentPath) {
// 鍙栧缑鎸囧畾鐩褰旷殑鍐呭瑰垪琛ㄣ
String[] fileNames = currentPath.list();
try {
for (int i = 0; i < fileNames.length; i++) {
File f = new File(currentPath.getPath(), fileNames[i]);
// 濡傛灉鏄鐩褰曪纴鍒欐樉绀虹洰褰曞悕钖庯纴阃掑綊璋幂敤锛屾樉绀哄瓙鐩褰旷殑鍐呭广
if (f.isDirectory()) {
// 浠ヨ勮寖镄勮矾寰勬牸寮忔樉绀虹洰褰曘
System.out.println(f.getCanonicalPath());
// 阃掑綊璋幂敤锛屾樉绀哄瓙鐩褰曘
listSubDir(f);
}
// 濡傛灉鏄鏂囦欢锛屽垯鏄剧ず鏂囦欢钖嶏纴涓嶅寘钖璺寰勪俊鎭銆
else {
System.out.println(f.getName());
}
}
} catch (IOException e) {
System.err.println("IOException");
}
}
}

package IO;

import java.io.*;

public class FileExample {
public FileExample() {
super();// 璋幂敤鐖剁被镄勬瀯阃犲嚱鏁
}

public static void main(String[] args) {
try {
String outfile = "demoout.xml";
// 瀹氢箟浜嗕竴涓鍙橀噺, 鐢ㄤ簬镙囱瘑杈揿嚭鏂囦欢
String infile = "demoin.xml";
// 瀹氢箟浜嗕竴涓鍙橀噺, 鐢ㄤ簬镙囱瘑杈揿叆鏂囦欢
DataOutputStream dt = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream(outfile)));
/**
* 鐢‵ileOutputStream瀹氢箟涓涓杈揿叆娴佹枃浠讹纴
* 铹跺悗鐢˙uferedOutputStream璋幂敤FileOutputStream瀵硅薄鐢熸垚涓涓缂揿啿杈揿嚭娴
* 铹跺悗鐢―ataOutputStream璋幂敤BuferedOutputStream瀵硅薄鐢熸垚鏁版嵁镙煎纺鍖栬緭鍑烘祦
*/
BufferedWriter NewFile = new BufferedWriter(new OutputStreamWriter(
dt, "gbk"));// 瀵逛腑鏂囩殑澶勭悊
DataInputStream rafFile1 = new DataInputStream(
new BufferedInputStream(new FileInputStream(infile)));
/**
*鐢‵ileInputStream瀹氢箟涓涓杈揿叆娴佹枃浠讹纴
* 铹跺悗鐢˙uferedInputStream璋幂敤FileInputStream瀵硅薄鐢熸垚涓涓缂揿啿杈揿嚭娴
* 锛屽叾钖庣敤DataInputStream涓璋幂敤BuferedInputStream瀵硅薄鐢熸垚鏁版嵁镙煎纺鍖栬緭鍑烘祦
*/
BufferedReader rafFile = new BufferedReader(new InputStreamReader(
rafFile1, "gbk"));// 瀵逛腑鏂囩殑澶勭悊
String xmlcontent = "";
char tag = 0;// 鏂囦欢鐢ㄥ瓧绗﹂浂缁撴潫
while (tag != (char) (-1)) {
xmlcontent = xmlcontent + tag + rafFile.readLine() + '\n';
}
NewFile.write(xmlcontent);
NewFile.flush();// 娓呯┖缂揿啿鍖
NewFile.close();
rafFile.close();
System.gc();// 寮哄埗绔嫔嵆锲炴敹鍨冨溇锛屽嵆閲婃斁鍐呭瓨銆
} catch (NullPointerException exc) {
exc.printStackTrace();
} catch (java.lang.IndexOutOfBoundsException outb) {
System.out.println(outb.getMessage());
outb.printStackTrace();
} catch (FileNotFoundException fex) {
System.out.println("fex" + fex.getMessage());
} catch (IOException iex) {
System.out.println("iex" + iex.getMessage());
}
}
}

package IO;

import java.io.*;

public class FileRandomRW {
// 闇瑕佽緭鍏ョ殑person鏁扮洰銆
public static int NUMBER = 3;

public static void main(String[] args) {
Persons[] people = new Persons[NUMBER];
people[0] = new Persons("寮犲嘲", 26, 2000, "N");
people[1] = new Persons("镩冲", 25, 50000, "Y");
people[2] = new Persons("𨱒庢湅", 50, 7000, "F");
try {
DataOutputStream out = new DataOutputStream(new FileOutputStream(
"peoplerandom.dat"));
// 灏嗕汉锻樻暟鎹淇濆瓨镊斥减eoplerandom.dat钬濅簩杩涘埗鏂囦欢涓銆
writeData(people, out);
// 鍏抽棴娴併
out.close();
// 浠庝簩杩涘埗鏂囦欢钬减eoplerandom.dat钬濅腑阃嗗簭璇诲彇鏁版嵁銆
RandomAccessFile inOut = new RandomAccessFile("peoplerandom.dat",
"rw");
Persons[] inPeople = readDataReverse(inOut);
// 杈揿嚭璇诲叆镄勬暟鎹銆
System.out.println("铡熷嬫暟鎹锛");
for (int i = 0; i < inPeople.length; i++) {
System.out.println(inPeople[i]);
}
// 淇鏀规枃浠剁殑绗涓夋浔璁板綍銆
inPeople[2].setSalary(4500);
// 灏嗕慨鏀圭粨鏋滃啓鍏ユ枃浠躲
inPeople[2].writeData(inOut, 3);
// 鍏抽棴娴併
inOut.close();
// 浠庢枃浠朵腑璇诲叆镄勭涓夋浔璁板綍锛屽苟杈揿嚭锛屼互楠岃瘉淇鏀圭粨鏋溿
RandomAccessFile in = new RandomAccessFile("peoplerandom.dat", "r");
Persons in3People = new Persons();
// 闅忔満璇荤涓夋浔璁板綍銆
in3People.readData(in, 3);
// 鍏抽棴娴併
in.close();
System.out.println("淇鏀瑰悗镄勮板綍");
System.out.println(in3People);
} catch (IOException exception) {
System.err.println("IOException");
}
}

// 灏嗘暟鎹鍐椤叆杈揿嚭娴併
static void writeData(Persons[] p, DataOutputStream out) throws IOException {
for (int i = 0; i < p.length; i++) {
p[i].writeData(out);
}
}

// 灏嗘暟鎹浠庤緭鍏ユ祦涓阃嗗簭璇诲嚭銆
static Persons[] readDataReverse(RandomAccessFile in) throws IOException {
// 銮峰缑璁板綍鏁扮洰銆
int record_num = (int) (in.length() / Persons.RECORD_LENGTH);
Persons[] p = new Persons[record_num];
// 阃嗗簭璇诲彇銆
for (int i = record_num - 1; i >= 0; i--) {
p[i] = new Persons();
// 鏂囦欢瀹氢綅銆
in.seek(i * Persons.RECORD_LENGTH);
p[i].readData(in, i + 1);
}
return p;
}
}

class Persons {
private String name;
private int age; // 4涓瀛楄妭
private double salary; // 8涓瀛楄妭
private String married;

public static final int NAME_LENGTH = 20; // 濮揿悕闀垮害
public static final int MARRIED_LENGTH = 2; // 濠氩惁闀垮害
public static final int RECORD_LENGTH = NAME_LENGTH * 2 + 4 + 8
+ MARRIED_LENGTH * 2;

public Persons() {
}

public Persons(String n, int a, double s) {
name = n;
age = a;
salary = s;
married = "F";
}

public Persons(String n, int a, double s, String m) {
name = n;
age = a;
salary = s;
married = m;
}

public String getName() {
return name;
}

public int getAge() {
return age;
}

public double getSalary() {
return salary;
}

public String getMarried() {
return married;
}

public String setName(String n) {
name = n;
return name;
}

public int setAge(int a) {
age = a;
return age;
}

public double setSalary(double s) {
salary = s;
return salary;
}

public String setMarried(String m) {
married = m;
return married;
}

// 璁剧疆杈揿嚭镙煎纺銆
public String toString() {
return getClass().getName() + "[name=" + name + ",age=" + age
+ ",salary=" + salary + ",married=" + married + "]";
}

// 鍐椤叆涓𨱒″浐瀹氶暱搴︾殑璁板綍锛屽嵆涓涓浜虹殑鏁版嵁鍒拌緭鍑烘祦銆
public void writeData(DataOutput out) throws IOException {
FixStringIO.writeFixString(name, NAME_LENGTH, out);
out.writeInt(age);
out.writeDouble(salary);
FixStringIO.writeFixString(married, MARRIED_LENGTH, out);
}

// 鍐椤叆涓𨱒″浐瀹氶暱搴︾殑璁板綍鍒伴殢链鸿诲彇鏂囦欢涓銆
private void writeData(RandomAccessFile out) throws IOException {
FixStringIO.writeFixString(name, NAME_LENGTH, out);
out.writeInt(age);
out.writeDouble(salary);
FixStringIO.writeFixString(married, MARRIED_LENGTH, out);
}

// 闅忔満鍐椤叆涓𨱒″浐瀹氶暱搴︾殑璁板綍鍒拌緭鍑烘祦镄勬寚瀹氢綅缃銆
public void writeData(RandomAccessFile out, int n) throws IOException {
out.seek((n - 1) * RECORD_LENGTH);
writeData(out);
}

// 浠庤緭鍏ユ祦闅忔満璇诲叆涓𨱒¤板綍锛屽嵆涓涓浜虹殑鏁版嵁銆
private void readData(RandomAccessFile in) throws IOException {
name = FixStringIO.readFixString(NAME_LENGTH, in);
age = in.readInt();
salary = in.readDouble();
married = FixStringIO.readFixString(MARRIED_LENGTH, in);
}

// 浠庤緭鍏ユ祦闅忔満璇诲叆鎸囧畾浣岖疆镄勮板綍銆
public void readData(RandomAccessFile in, int n) throws IOException {
in.seek((n - 1) * RECORD_LENGTH);
readData(in);
}
}

// 瀵瑰浐瀹氶暱搴﹀瓧绗︿覆浠庢枃浠惰诲嚭銆佸啓鍏ユ枃浠
class FixStringIO {
// 璇诲彇锲哄畾闀垮害镄刄nicode瀛楃︿覆銆
public static String readFixString(int size, DataInput in)
throws IOException {
StringBuffer b = new StringBuffer(size);
int i = 0;
boolean more = true;

while (more && i < size) {
char ch = in.readChar();
i++;
if (ch == 0) {
more = false;
} else {
b.append(ch);
}
}
// 璺宠繃鍓╀綑镄勫瓧鑺伞
in.skipBytes(2 * (size - i));
return b.toString();
}

// 鍐椤叆锲哄畾闀垮害镄刄nicode瀛楃︿覆銆
public static void writeFixString(String s, int size, DataOutput out)
throws IOException {
int i;
for (i = 0; i < size; i++) {
char ch = 0;
if (i < s.length()) {
ch = s.charAt(i);
}
out.writeChar(ch);
}
}
}

package IO;

import java.io.*;
import java.util.*;

public class FileRW {
// 闇瑕佽緭鍏ョ殑person鏁扮洰銆
public static int NUMBER = 3;

public static void main(String[] args) {
Person[] people = new Person[NUMBER];
// 𨱌傛椂瀹圭撼杈揿叆鏁版嵁镄勪复镞跺瓧绗︿覆鏁扮粍銆
String[] field = new String[4];
// 鍒濆嫔寲field鏁扮粍銆
for (int i = 0; i < 4; i++) {
field[i] = "";
}
// IO镎崭綔蹇呴’鎹曡幏IO寮傚父銆
try {
// 鐢ㄤ簬瀵筬ield鏁扮粍杩涜屽炲姞鎺у埗銆
int fieldcount = 0;

// 鍏堜娇鐢⊿ystem.in鏋勯营nputStreamReader锛屽啀鏋勯燘ufferedReader銆
BufferedReader stdin = new BufferedReader(new InputStreamReader(
System.in));
for (int i = 0; i < NUMBER; i++) {
fieldcount = 0;
System.out.println("The number " + (i + 1) + " person");
System.out
.println("Enter name,age,salary,married(optional),please separate fields by ':'");
// 璇诲彇涓琛屻
String personstr = stdin.readLine();
// 璁剧疆鍒嗛殧绗︺
StringTokenizer st = new StringTokenizer(personstr, ":");
// 鍒ゆ柇鏄钖﹁缮链夊垎闅旂﹀彲鐢ㄣ
while (st.hasMoreTokens()) {
field[fieldcount] = st.nextToken();
fieldcount++;
}
// 濡傛灉杈揿叆married锛屽垯field[3]涓崭负绌猴纴璋幂敤鍏锋湁锲涗釜鍙傛暟镄凯erson鏋勯犲嚱鏁般
if (field[3] != "") {
people[i] = new Person(field[0],
Integer.parseInt(field[1]), Double
.parseDouble(field[2]), field[3]);
// 缃甪ield[3]涓虹┖锛屼互澶囦笅娆¤緭鍏ヤ娇鐢ㄣ
field[3] = "";
}
// 濡傛灉链杈揿叆married锛屽垯field[3]涓虹┖锛岃皟鐢ㄥ叿链変笁涓鍙傛暟镄凯erson鏋勯犲嚱鏁般
else {
people[i] = new Person(field[0],
Integer.parseInt(field[1]), Double
.parseDouble(field[2]));
}
}
// 灏呜緭鍏ョ殑鏁版嵁淇濆瓨镊斥减eople.dat钬濇枃链鏂囦欢涓銆
PrintWriter out = new PrintWriter(new BufferedWriter(
new FileWriter("people.dat")));
writeData(people, out);
// 鍏抽棴娴併
out.close();
// 浠庢枃浠垛减eople.dat钬濊诲彇鏁版嵁銆
BufferedReader in = new BufferedReader(new FileReader("people.dat"));
Person[] inPeople = readData(in);
// 鍏抽棴娴併
in.close();
// 杈揿嚭浠庢枃浠朵腑璇诲叆镄勬暟鎹銆
for (int i = 0; i < inPeople.length; i++) {
System.out.println(inPeople[i]);
}
} catch (IOException exception) {
System.err.println("IOException");
}
}

// 灏嗘墍链夋暟鎹鍐椤叆杈揿嚭娴併
static void writeData(Person[] p, PrintWriter out) throws IOException {
// 鍐椤叆璁板綍𨱒℃暟锛屽嵆浜烘暟銆
out.println(p.length);
for (int i = 0; i < p.length; i++) {
p[i].writeData(out);
}
}

// 灏嗘墍链夋暟鎹浠庤緭鍏ユ祦涓璇诲嚭銆
static Person[] readData(BufferedReader in) throws IOException {
// 銮峰彇璁板綍𨱒℃暟锛屽嵆浜烘暟銆
int n = Integer.parseInt(in.readLine());

Person[] p = new Person[n];
for (int i = 0; i < n; i++) {
p[i] = new Person();
p[i].readData(in);
}
return p;
}
}

class Person {
private String name;
private int age;
private double salary;
private String married;

public Person() {
}

public Person(String n, int a, double s) {
name = n;
age = a;
salary = s;
married = "F";
}

public Person(String n, int a, double s, String m) {
name = n;
age = a;
salary = s;
married = m;
}

public String getName() {
return name;
}

public int getAge() {
return age;
}

public double getSalary() {
return salary;
}

public String getMarried() {
return married;
}

// 璁剧疆杈揿嚭镙煎纺銆
public String toString() {
return getClass().getName() + "[name=" + name + ",age=" + age
+ ",salary=" + salary + ",married=" + married + "]";
}

// 鍐椤叆涓𨱒¤板綍锛屽嵆涓涓浜虹殑鏁版嵁鍒拌緭鍑烘祦銆
public void writeData(PrintWriter out) throws IOException {
// 镙煎纺鍖栬緭鍑恒
out.println(name + ":" + age + ":" + salary + ":" + married);
}

// 浠庤緭鍏ユ祦璇诲叆涓𨱒¤板綍锛屽嵆涓涓浜虹殑鏁版嵁銆
public void readData(BufferedReader in) throws IOException {
String s = in.readLine();
StringTokenizer t = new StringTokenizer(s, ":");
name = t.nextToken();
age = Integer.parseInt(t.nextToken());
salary = Double.parseDouble(t.nextToken());
married = t.nextToken();
}
}

package IO;

import java.io.IOException;

public class FileStdRead {
public static void main(String[] args) throws IOException {
int b = 0;
char c = ' ';
System.out.println("璇疯緭鍏ワ细");
while (c != 'q') {
int a = System.in.read();
c = (char) a;
b++;
System.out.println((char) a);
}
System.err.print("counted\t" + b + "\ttotalbytes.");
}

}
//璇诲彇杈揿叆镄勬暟鎹,鐩村埌鏁版嵁涓链塓杩欎釜瀛楁瘝铹

package IO;

import java.io.*;

public class IOStreamExample {
public static void main(String[] args) throws IOException {
// 1. 璇诲叆涓琛屾暟鎹:
BufferedReader in = new BufferedReader(new FileReader(
"FileStdRead.java"));
String s, s2 = new String();
while ((s = in.readLine()) != null) {
s2 += s + "\n";
}
in.close();
BufferedReader stdin = new BufferedReader(new InputStreamReader(
System.in));
System.out.print("Enter a line:");
System.out.println(stdin.readLine());
// 2. 浠庡唴瀛树腑璇诲叆
StringReader in2 = new StringReader(s2);
int c;
while ((c = in2.read()) != -1) {
System.out.print((char) c);
}
// 3. 镙煎纺鍖栧唴瀛樿緭鍏
try {
DataInputStream in3 = new DataInputStream(new ByteArrayInputStream(
s2.getBytes()));
while (true) {
System.out.print((char) in3.readByte());
}
} catch (EOFException e) {
System.err.println("End of stream");
}
// 4. 鏂囦欢杈揿叆
try {
BufferedReader in4 = new BufferedReader(new StringReader(s2));
PrintWriter out1 = new PrintWriter(new BufferedWriter(
new FileWriter("IODemo.out")));
int lineCount = 1;
while ((s = in4.readLine()) != null) {
out1.println(lineCount++ + ": " + s);
}
out1.close();
} catch (EOFException e) {
System.err.println("End of stream");
}
// 5. 鎺ユ敹鍜屼缭瀛樻暟鎹
try {
DataOutputStream out2 = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream("Data.txt")));
out2.writeDouble(3.14159);
out2.writeUTF("That was pi");
out2.writeDouble(1.41413);
out2.writeUTF("Square root of 2");
out2.close();
DataInputStream in5 = new DataInputStream(new BufferedInputStream(
new FileInputStream("Data.txt")));

System.out.println(in5.readDouble());

System.out.println(in5.readUTF());
System.out.println(in5.readDouble());
System.out.println(in5.readUTF());
} catch (EOFException e) {
throw new RuntimeException(e);
}
// 6. 闅忔満璇诲彇鏂囦欢鍐呭
RandomAccessFile rf = new RandomAccessFile("rtest.dat", "rw");
for (int i = 0; i < 10; i++) {
rf.writeDouble(i * 1.414);
}
rf.close();
rf = new RandomAccessFile("rtest.dat", "rw");
rf.seek(5 * 8);
rf.writeDouble(47.0001);
rf.close();
rf = new RandomAccessFile("rtest.dat", "r");
for (int i = 0; i < 10; i++) {
System.out.println("Value " + i + ": " + rf.readDouble());
}
rf.close();
}
}

package IO;

import java.io.*;

/**
* <p>
* Title: JAVA杩涢桩璇绐
* </p>
*
* @author 寮犲嘲
* @version 1.0
*/
public class MakeDirectoriesExample {
private static void fileattrib(File f) {
System.out.println("缁濆硅矾寰: " + f.getAbsolutePath() + "\n 鍙璇诲睘镐: "
+ f.canRead() + "\n 鍙瀹氩睘镐: " + f.canWrite() + "\n 鏂囦欢钖: "
+ f.getName() + "\n 鐖剁洰褰: " + f.getParent() + "\n 褰揿墠璺寰: "
+ f.getPath() + "\n 鏂囦欢闀垮害: " + f.length() + "\n 链钖庢洿鏂版棩链: "
+ f.lastModified());
if (f.isFile()) {
System.out.println("杈揿叆镄勬槸涓涓鏂囦欢");
} else if (f.isDirectory()) {
System.out.println("杈揿叆镄勬槸涓涓鐩褰");
}
}

public static void main(String[] args) {
if (args.length < 1) {
args = new String[3];
}
args[0] = "d";
args[1] = "test1.txt";
args[2] = "test2.txt";
File old = new File(args[1]), rname = new File(args[2]);
old.renameTo(rname);
fileattrib(old);
fileattrib(rname);
int count = 0;
boolean del = false;
if (args[0].equals("d")) {
count++;
del = true;
}
count--;
while (++count < args.length) {
File f = new File(args[count]);
if (f.exists()) {
System.out.println(f + " 鏂囦欢宸辩粡瀛桦湪");
if (del) {
System.out.println("鍒犻櫎鏂囦欢" + f);
f.delete();
}
} else { // 濡傛灉鏂囦欢涓嶅瓨鍦
if (!del) {
f.mkdirs();
System.out.println("鍒涘缓鏂囦欢锛 " + f);
}
}
fileattrib(f);
}
}
}

㈤怎么在cmd里面运行 java

方法如下:

1、首先我们在命令行运行Java程序需要借助jdk的环境依赖，打开jdk包，需要找到javac和java两个文件，如下图所示

(5)java项目编译跳过test目录扩展阅读：

命令提示符是在操作系统中，提示进行命令输入的一种工作提示符。在不同的操作系统环境下，命令提示符各不相同。

在windows环境下，命令行程序为cmd.exe，是一个32位的命令行程序，微软Windows系统基于Windows上的命令解释程序，类似于微软的DOS操作系统。

输入一些命令，cmd.exe可以执行，比如输入shutdown -s -t 30就会在30秒后关机。总之，它非常有用。打开方法：开始-所有程序-附件或开始-寻找-输入：cmd/cmd.exe 回车。它也可以执行BAT文件。

一般说的“命令行”是指linux命令，linux命令是对Linux系统进行管理的命令。对于Linux系统来说，无论是中央处理器、内存、磁盘驱动器、键盘、鼠标，还是用户等都是文件，Linux系统管理的命令是它正常运行的核心，与之前的DOS命令类似。linux命令在系统中有两种类型：内置Shell（外壳）命令和Linux命令。

运行方法

⒈ 点击开始--运行--输入--CMD 回车（或按windows键和R键弹出运行框—输入CMD回车）[1]

⒉Windows XP中单击“开始→所有→附件→命令提示符”即可打开命令提示符。

系统会默认定位到“X:Documents and Settings当前用户名”下。

⒊点击我的电脑--打开系统盘（C：）--WINDOWS--system32--CMD.EXE

建立一个快捷方式，将绝对路径输入再运行也可快速打开命令提示符。

⒋在桌面或任意磁盘新建一个TXT--输入CMD并保存--修改扩展名为.BAT（文件名随意）--运行即可

这样的特点是运行这个BAT后，命令提示符下的路径直接显示你BAT所在的目录路径。

⒌win7的运行除了以上的方法外还可以系统桌面上先按住“Shift”键，单击鼠标右键出现的菜单，选择“在此处打开命令行窗口”后，就出现了命令提示符。

命令提示符默认位置更改方法

单击“开始→控制面板→性能和维护→管理工具→计算机管理”，（经典分类视图下跳过第3步）

依次展开“系统工具→本地用户和组→用户”，然后在右侧窗口中双击当前登陆的用户名，

在打开的“属性”对话框单击“配置文件”选项卡，在“主文件夹”下的“本地路径”后面键入

你想更的当前盘符或当前目录，如“E:”，然后单击“应用→确定”，重新启动计算机即可完成更改。

㈥有没有技术大牛了解java开发，测试和CI的关

大家可能对如下情景比较熟悉：

如果开发过SSH的web项目，启动服务器可能会比较慢，有的项目甚至需要1分多钟，甚至更多，这个启动时间的等待一般就浪费了；
在开发项目时，有些功能比较复杂，当时觉得思路特清晰，但是过了一段时间后，自己也忘了，完善功能时频繁出现bug，降低开发速度；
在维护项目时，不知道自己修改的对还是不对，是否存在隐患；维护速度降下来了；
如果开发一个很多人都使用的接口，典型的如用户系统，要保证比如升级时向下兼容；
在团队间协作时，有时候只定义好接口，对方还没有给实现，如何进行同步开发？

如上问题，估计只要是个开发人员，都可能遇到过；如果此时有了单元/集成测试，那我们能很好的解决这些问题。（注：加下来如果没有特殊情况，不刻意强调单元测试/集成测试，即提到测试是指的是单元/集成测试）

我从以下几个方面介绍测试：

1、为什么需要测试？

2、如何进行测试？

3、测试有哪些好处？

4、一切都需要测试吗？

1、为什么需要测试？

测试的目的是什么？我的理解是：

缩短发现问题到解决问题的速度；
给程序一个修改后能验证是否正确的保证；（回归测试）
如果是开源软件，我们可以通过单元测试了解其是怎么使用的；比如我之前通过cglib的单元测试学习过cglib的使用；

所以如果你遇到如上问题，就需要写测试。写测试可能是为了自己（1、2）；也可能是为了帮助别人（3）。

2、如何进行测试？

很多朋友不知道如何进行测试，其实测试很简单，别把它想复杂了，按照自己的想法测试每个功能点是否正确即可。

2.1、测试流程

单元测试流程

<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>native2ascii-maven-plugin</artifactId>
<version>1.0-alpha-1</version>
<executions>
<execution>
<phase>generate-resources</phase>
<goals>
<goal>native2ascii</goal>
</goals>
<configuration>
<encoding>UTF-8</encoding>
<src>src/main/messages</src>
<dest>target/${project.artifactId}/WEB-INF/classes</dest>
<includes>messages.properties</includes>
</configuration>
</execution>
</executions>
<dependencies>
<dependency>
<groupId>com.sun</groupId>
<artifactId>tools</artifactId>
<version>1.7.0</version>
<scope>system</scope>
<systemPath>${java.home}/../lib/tools.jar</systemPath>
</dependency>
</dependencies>
</plugin>

如果使用mysql，端口只能是3306。

如果想开端口测试，这是不允许的。

如下是我项目中的一个配置.travis.yml，放到项目的根下即可：

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

language: java 语言

env: 环境

- DB=mysql 使用mysql

jdk:

- openjdk jdk使用openjdk

mysql:

database: es 数据库名为es

username: root 用户名为root

password : 密码为空

encoding: utf8 编码为utf8

install: 安装时执行的脚本

- mvn install -Dmaven.test.skip=true mvn安装并跳过测试

before_script: script之前执行的测试

- cd web

- mvn db:create 创建数据库的mvn命令（此处使用了maven-db-plugin 插件）

- mvn db:schema 创建脚本的mvn命令

- mvn db:data 安装数据的mvn命令

- cd ..

script: 测试时执行的脚步

- cd common

- mvn test 测试common子模块

- cd ..

- cd web

- mvn test -Pit 测试web子模块，并指定使用it profile测试（即集成测试的配置，具体参考pom.xml中的profile/it）

notifications: 触发

email: 测试完成后测试报告发到哪

- [email protected]

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

持续集成不能修复代码的错误，而是和单元测试一样，缩短发现问题带解决问题的时间，这样可以提高开发效率，降低项目风险，提高项目的稳定性。而且尤其是团队协作时，可以发现其他人的代码是否对自己的代码产生影响。

到此我们利用单元测试+CI可以加速开发人员的开发速度。利用好单元测试和CI，不要纯粹为了单元测试和CI而去做这些事情。

本文没有介绍TDD，TDD并不会那么美好，我认为我们可以借鉴TDD的一些思想，但决不能迷信TDD，有时候，尤其如开发企业应用，先写功能再写测试可能效率更高，而且大部分时候是不需要TDD的。而且我也没能在实际项目中获取太多TDD的好处，但是我获得了测试的好处。

本文也没有介绍测试覆盖率，我认为不要一味的追求覆盖率，有时候有的覆盖率没有任何意义。所以不要让为了覆盖率而覆盖率拖慢了项目开发进度。

正如stackoverflow上的一篇帖子《How deep are your unit tests?》上Kent Beck的回答：

写道

老板为我的代码付报酬，而不是测试，所以，我对此的价值观是——测试越少越好，少到你对你的代码质量达到了某种自信。

可以前往coolshell的“单元测试要做多细？”去得到一些经验。

导航:首页 > 源码编译 > java项目编译跳过test目录

java项目编译跳过test目录

与java项目编译跳过test目录相关的资料