java項目編譯跳過test目錄

㈠ 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>

• <!--native2ascii使用的tools.jar-->

• <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的「單元測試要做多細？」去得到一些經驗。