yehuijia
- 浏览: 9685 次
- 性别:
- 来自: 上海
-
文章分类
最新评论
-
xiaoane：
<div class="quote_title ...
[MYSQL] 创建远程登陆用户并授权 -
xiaoane：
我是在linux vm上安装的mysql，授权已经做了。lin ...
[MYSQL] 创建远程登陆用户并授权 -
二进制：
总结的很好，受益匪浅。
SSH总结
面试二
最近参加了几次面试，发现公司的笔试题目有一些相似之处，就总结一下：
一般会从下面几个方面考，不管是面试C++,C#,java都是
首先是关于关键字和标示常量的考察
然后是关于类和接口的试题
然后是关于array,io和socket的试题
然后是关于数据库的各种sql语句的考察
然后是排序，包括快速排序，插入排序，选择排序
然后是设计模式的考察
一下以java为例子说明一些自己遇到的：
1、冒泡排序 Bubble Sort
最简单的排序方法是冒泡排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。这个算法可实现如下。
算法如下：
/**
*冒泡排序
*@paramsrc待排序数组
*/
void doBubbleSort(int[] src)
{
int len=src.length;
for(int i=0;i<len;i++)
{
for(int j=i+1;j<len;j++)
{
int temp;
if(src[i]>src[j])
{
temp=src[j];
src[j]=src[i];
src[i]=temp;
}
}
printResult(i,src);
}
}
2、选择排序 Selection Sort
选择排序的基本思想是：对待排序的记录序列进行n-1遍的处理，第1遍处理是将L[1..n]中最小者与L[1]交换位置，第2遍处理是将L[2..n]中最小者与L[2]交换位置，......，第i遍处理是将L[i..n]中最小者与L[i]交换位置。这样，经过i遍处理之后，前i个记录的位置就已经按从小到大的顺序排列好了。当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换位置，按从大到小的顺序进行排序处理。
算法如下：
/**
*选择排序
*@paramsrc待排序的数组
*/
void doChooseSort(int[] src)
{
int len=src.length;
int temp;
for(int i=0;i<len;i++)
{
temp=src[i];
int j;
int samllestLocation=i;//最小数的下标
for(j=i+1;j<len;j++)
{
if(src[j]<temp)
{
temp=src[j];//取出最小值
samllestLocation=j;//取出最小值所在下标
}
}
src[samllestLocation]=src[i];
src[i]=temp;
printResult(i,src);
}
}
3、插入排序 Insertion Sort
插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i]又是排好序的序列。要达到这个目的，我们可以用顺序比较的方法。首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]騆[1..i]已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。简言之,插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。插入排序方法分直接插入排序和折半插入排序两种，这里只介绍直接插入排序，折半插入排序留到“查找”内容中进行。在下面的插入排序算法中，为了写程序方便我们可以引入一个哨兵元素L[0]，它小于L[1..n]中任一记录。所以，我们设元素的类型ElementType中有一个常量-∞，它比可能出现的任何记录都小。如果常量-∞不好事先确定，就必须在决定L[i]是否向前移动之前检查当前位置是否为1，若当前位置已经为1时就应结束第i遍的处理。另一个办法是在第i遍处理开始时，就将L[i]放入L[0]中，这样也可以保证在适当的时候结束第i遍处理。下面的算法中将对当前位置进行判断。
算法如下：
/**
*插入排序(WHILE循环实现)
*@paramsrc待排序数组
*/
void doInsertSort1(int[] src)
{
int len=src.length;
for(int i=1;i<len;i++)
{
int temp=src[i];
int j=i;
while(src[j-1]>temp)
{
src[j]=src[j-1];
j--;
if(j<=0)
break;
}
src[j]=temp;
printResult(i+1,src);
}
}
/**
*插入排序(FOR循环实现)
*@paramsrc待排序数组
*/
void doInsertSort2(int[] src)
{
int len=src.length;
for(int i=1;i<len;i++)
{
int j;
int temp=src[i];
for(j=i;j>0;j--)
{
if(src[j-1]>temp)
{
src[j]=src[j-1];
}else//如果当前的数，不小前面的数，那就说明不小于前面所有的数，
//因为前面已经是排好了序的，所以直接通出当前一轮的比较
break;
}
src[j]=temp;
printResult(i,src);
}
}
4:快速排序
是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。最坏情况的时间复杂度为O(n2)，最好情况时间复杂度为O(nlog2n)。
假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一趟快速排序的算法是：
1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；
2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；
3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；
4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；
5）、重复第3、4步，直到I=J；
例如：待排序的数组A的值分别是：（初始关键数据X：=49）
A[1] A[2] A[3] A[4] A[5] A[6] A[7]：
49 38 65 97 76 13 27
进行第一次交换后： 27 38 65 97 76 13 49
( 按照算法的第三步从后面开始找)
进行第二次交换后： 27 38 49 97 76 13 65
( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时I：=3 )
进行第三次交换后： 27 38 13 97 76 49 65
( 按照算法的第五步将又一次执行算法的第三步从后开始找)
进行第四次交换后： 27 38 13 49 76 97 65
( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时J：=4 )
此时再执行第三步的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后的结果是：27 38 13 49 76 97 65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。
快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：
初始状态 {49 38 65 97 76 13 27}
进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65}
分别对前后两部分进行快速排序 {13} 27 {38}
结束 结束 {49 65} 76 {97}
49 {65} 结束
结束
图6 快速排序全过程
1）、设有N（假设N=10）个数，存放在S数组中；
2）、在S[1。。N]中任取一个元素作为比较基准，例如取T=S[1]，起目的就是在定出T应在排序结果中的位置K，这个K的位置在：S[1。。K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的数都小于S[K]，在S[K]以后的数都大于S[K]；
3）、利用分治思想（即大化小的策略）可进一步对S[1。。K-1]和S[K+1。。N]两组数据再进行快速排序直到分组对象只有一个数据为止。
如具体数据如下，那么第一躺快速排序的过程是：
数组下标： 1 2 3 4 5 6 7 8 9 10
45 36 18 53 72 30 48 93 15 36
I J
（1） 36 36 18 53 72 30 48 93 15 45
（2） 36 36 18 45 72 30 48 93 15 53
（3） 36 36 18 15 72 30 48 93 45 53
（4） 36 36 18 15 45 30 48 93 72 53
（5） 36 36 18 15 30 45 48 93 72 53
通过一躺排序将45放到应该放的位置K，这里K=6，那么再对S[1。。5]和S[6。。10]分别进行快速排序。
/**
* 交换指定数组a的两个变量的值
* @param a 数组应用
* @param i 数组下标
* @param j 数组上标
*/
public static void swap(int a[], int i, int j) {
if(i == j) return;
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
/**
*
* @param array 待排序数组
* @param low 数组下标下界
* @param high 数组下标上界
* @return pivot
*/
public static int partition(int array[], int low, int high) {
//当前位置为第一个元素所在位置
int p_pos = low;
//采用第一个元素为轴
int pivot = array[p_pos];
for (int i = low + 1; i <= high; i++) {
if (array[i] < pivot) {
p_pos++;
swap(array, p_pos, i);
}
}
swap(array, low, p_pos);
return p_pos;
}
/**
* 快速排序实现
* @param array
* @param low
* @param high
*/
public static void quickSort(int array[], int low, int high) {
if (low < high) {
int pivot = partition(array, low, high);
quickSort(array, low, pivot - 1);
quickSort(array, pivot + 1, high);
}
}
子类的static方法和父类有同名、同参数的static方法，但他们之间没什么覆盖、继承的关系，你调用的 时候看是用那个类名引用了，用子类的类名就调用子类的static方法，用父类类名就调用父类的static方法。 static 顾名思义，就是静态的，他是方法的，他属于这个类，由于是类的方法，他可以直接引用类名来引用方法，他既不能被子类覆盖，也不能被子类继承。简单的说，他是在编译的时候就和类帮定在一起了，不能被运行时动态加载。
java中多种方式读文件
一、多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
public class ReadFromFile {
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
* @param fileName 文件的名
*/
public static void readFileByBytes(String fileName){
File file = new File(fileName);
InputStream in = null;
try {
System.out.println("以字节为单位读取文件内容，一次读一个字节：");
// 一次读一个字节
in = new FileInputStream(file);
int tempbyte;
while((tempbyte=in.read()) != -1){
System.out.write(tempbyte);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
try {
System.out.println("以字节为单位读取文件内容，一次读多个字节：");
//一次读多个字节
byte[] tempbytes = new byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//读入多个字节到字节数组中，byteread为一次读入的字节数
while ((byteread = in.read(tempbytes)) != -1){
System.out.write(tempbytes, 0, byteread);
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null){
try {
in.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
* @param fileName 文件名
*/
public static void readFileByChars(String fileName){
File file = new File(fileName);
Reader reader = null;
try {
System.out.println("以字符为单位读取文件内容，一次读一个字节：");
// 一次读一个字符
reader = new InputStreamReader(new FileInputStream(file));
int tempchar;
while ((tempchar = reader.read()) != -1){
//对于windows下，rn这两个字符在一起时，表示一个换行。
//但如果这两个字符分开显示时，会换两次行。
//因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。
if (((char)tempchar) != 'r'){
System.out.print((char)tempchar);
}
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
System.out.println("以字符为单位读取文件内容，一次读多个字节：");
//一次读多个字符
char[] tempchars = new char[30];
int charread = 0;
reader = new InputStreamReader(new FileInputStream(fileName));
//读入多个字符到字符数组中，charread为一次读取字符数
while ((charread = reader.read(tempchars))!=-1){
//同样屏蔽掉r不显示
if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){
System.out.print(tempchars);
}else{
for (int i=0; i<charread; i++){
if(tempchars[i] == 'r'){
continue;
}else{
System.out.print(tempchars[i]);
}
}
}
}
} catch (Exception e1) {
e1.printStackTrace();
}finally {
if (reader != null){
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
* @param fileName 文件名
*/
public static void readFileByLines(String fileName){
File file = new File(fileName);
BufferedReader reader = null;
try {
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
//一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null){
//显示行号
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null){
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 随机读取文件内容
* @param fileName 文件名
*/
public static void readFileByRandomAccess(String fileName){
RandomAccessFile randomFile = null;
try {
System.out.println("随机读取一段文件内容：");
// 打开一个随机访问文件流，按只读方式
randomFile = new RandomAccessFile(fileName, "r");
// 文件长度，字节数
long fileLength = randomFile.length();
// 读文件的起始位置
int beginIndex = (fileLength > 4) ? 4 : 0;
//将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes = new byte[10];
int byteread = 0;
//一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
//将一次读取的字节数赋给byteread
while ((byteread = randomFile.read(bytes)) != -1){
System.out.write(bytes, 0, byteread);
}
} catch (IOException e){
e.printStackTrace();
} finally {
if (randomFile != null){
try {
randomFile.close();
} catch (IOException e1) {
}
}
}
}
/**
* 显示输入流中还剩的字节数
* @param in
*/
private static void showAvailableBytes(InputStream in){
try {
System.out.println("当前字节输入流中的字节数为:" + in.available());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}
二、将内容追加到文件尾部
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 将内容追加到文件尾部
*/
public class AppendToFile {
/**
* A方法追加文件：使用RandomAccessFile
* @param fileName 文件名
* @param content 追加的内容
*/
public static void appendMethodA(String fileName,
String content){
try {
// 打开一个随机访问文件流，按读写方式
RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
// 文件长度，字节数
long fileLength = randomFile.length();
//将写文件指针移到文件尾。
randomFile.seek(fileLength);
randomFile.writeBytes(content);
randomFile.close();
} catch (IOException e){
e.printStackTrace();
}
}
/**
* B方法追加文件：使用FileWriter
* @param fileName
* @param content
*/
public static void appendMethodB(String fileName, String content){
try {
//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer = new FileWriter(fileName, true);
writer.write(content);
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
String content = "new append!";
//按方法A追加文件
AppendToFile.appendMethodA(fileName, content);
AppendToFile.appendMethodA(fileName, "append end. n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
//按方法B追加文件
AppendToFile.appendMethodB(fileName, content);
AppendToFile.appendMethodB(fileName, "append end. n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
}
}
最近参加了几次面试，发现公司的笔试题目有一些相似之处，就总结一下：
一般会从下面几个方面考，不管是面试C++,C#,java都是
首先是关于关键字和标示常量的考察
然后是关于类和接口的试题
然后是关于array,io和socket的试题
然后是关于数据库的各种sql语句的考察
然后是排序，包括快速排序，插入排序，选择排序
然后是设计模式的考察
一下以java为例子说明一些自己遇到的：
1、冒泡排序 Bubble Sort
最简单的排序方法是冒泡排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。这个算法可实现如下。
算法如下：
/**
*冒泡排序
*@paramsrc待排序数组
*/
void doBubbleSort(int[] src)
{
int len=src.length;
for(int i=0;i<len;i++)
{
for(int j=i+1;j<len;j++)
{
int temp;
if(src[i]>src[j])
{
temp=src[j];
src[j]=src[i];
src[i]=temp;
}
}
printResult(i,src);
}
}
2、选择排序 Selection Sort
选择排序的基本思想是：对待排序的记录序列进行n-1遍的处理，第1遍处理是将L[1..n]中最小者与L[1]交换位置，第2遍处理是将L[2..n]中最小者与L[2]交换位置，......，第i遍处理是将L[i..n]中最小者与L[i]交换位置。这样，经过i遍处理之后，前i个记录的位置就已经按从小到大的顺序排列好了。当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换位置，按从大到小的顺序进行排序处理。
算法如下：
/**
*选择排序
*@paramsrc待排序的数组
*/
void doChooseSort(int[] src)
{
int len=src.length;
int temp;
for(int i=0;i<len;i++)
{
temp=src[i];
int j;
int samllestLocation=i;//最小数的下标
for(j=i+1;j<len;j++)
{
if(src[j]<temp)
{
temp=src[j];//取出最小值
samllestLocation=j;//取出最小值所在下标
}
}
src[samllestLocation]=src[i];
src[i]=temp;
printResult(i,src);
}
}
3、插入排序 Insertion Sort
插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i]又是排好序的序列。要达到这个目的，我们可以用顺序比较的方法。首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]騆[1..i]已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。简言之,插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。插入排序方法分直接插入排序和折半插入排序两种，这里只介绍直接插入排序，折半插入排序留到“查找”内容中进行。在下面的插入排序算法中，为了写程序方便我们可以引入一个哨兵元素L[0]，它小于L[1..n]中任一记录。所以，我们设元素的类型ElementType中有一个常量-∞，它比可能出现的任何记录都小。如果常量-∞不好事先确定，就必须在决定L[i]是否向前移动之前检查当前位置是否为1，若当前位置已经为1时就应结束第i遍的处理。另一个办法是在第i遍处理开始时，就将L[i]放入L[0]中，这样也可以保证在适当的时候结束第i遍处理。下面的算法中将对当前位置进行判断。
算法如下：
/**
*插入排序(WHILE循环实现)
*@paramsrc待排序数组
*/
void doInsertSort1(int[] src)
{
int len=src.length;
for(int i=1;i<len;i++)
{
int temp=src[i];
int j=i;
while(src[j-1]>temp)
{
src[j]=src[j-1];
j--;
if(j<=0)
break;
}
src[j]=temp;
printResult(i+1,src);
}
}
/**
*插入排序(FOR循环实现)
*@paramsrc待排序数组
*/
void doInsertSort2(int[] src)
{
int len=src.length;
for(int i=1;i<len;i++)
{
int j;
int temp=src[i];
for(j=i;j>0;j--)
{
if(src[j-1]>temp)
{
src[j]=src[j-1];
}else//如果当前的数，不小前面的数，那就说明不小于前面所有的数，
//因为前面已经是排好了序的，所以直接通出当前一轮的比较
break;
}
src[j]=temp;
printResult(i,src);
}
}
4:快速排序
是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。最坏情况的时间复杂度为O(n2)，最好情况时间复杂度为O(nlog2n)。
假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一趟快速排序的算法是：
1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；
2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；
3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；
4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；
5）、重复第3、4步，直到I=J；
例如：待排序的数组A的值分别是：（初始关键数据X：=49）
A[1] A[2] A[3] A[4] A[5] A[6] A[7]：
49 38 65 97 76 13 27
进行第一次交换后： 27 38 65 97 76 13 49
( 按照算法的第三步从后面开始找)
进行第二次交换后： 27 38 49 97 76 13 65
( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时I：=3 )
进行第三次交换后： 27 38 13 97 76 49 65
( 按照算法的第五步将又一次执行算法的第三步从后开始找)
进行第四次交换后： 27 38 13 49 76 97 65
( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时J：=4 )
此时再执行第三步的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后的结果是：27 38 13 49 76 97 65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。
快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：
初始状态 {49 38 65 97 76 13 27}
进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65}
分别对前后两部分进行快速排序 {13} 27 {38}
结束 结束 {49 65} 76 {97}
49 {65} 结束
结束
图6 快速排序全过程
1）、设有N（假设N=10）个数，存放在S数组中；
2）、在S[1。。N]中任取一个元素作为比较基准，例如取T=S[1]，起目的就是在定出T应在排序结果中的位置K，这个K的位置在：S[1。。K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的数都小于S[K]，在S[K]以后的数都大于S[K]；
3）、利用分治思想（即大化小的策略）可进一步对S[1。。K-1]和S[K+1。。N]两组数据再进行快速排序直到分组对象只有一个数据为止。
如具体数据如下，那么第一躺快速排序的过程是：
数组下标： 1 2 3 4 5 6 7 8 9 10
45 36 18 53 72 30 48 93 15 36
I J
（1） 36 36 18 53 72 30 48 93 15 45
（2） 36 36 18 45 72 30 48 93 15 53
（3） 36 36 18 15 72 30 48 93 45 53
（4） 36 36 18 15 45 30 48 93 72 53
（5） 36 36 18 15 30 45 48 93 72 53
通过一躺排序将45放到应该放的位置K，这里K=6，那么再对S[1。。5]和S[6。。10]分别进行快速排序。
/**
* 交换指定数组a的两个变量的值
* @param a 数组应用
* @param i 数组下标
* @param j 数组上标
*/
public static void swap(int a[], int i, int j) {
if(i == j) return;
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
/**
*
* @param array 待排序数组
* @param low 数组下标下界
* @param high 数组下标上界
* @return pivot
*/
public static int partition(int array[], int low, int high) {
//当前位置为第一个元素所在位置
int p_pos = low;
//采用第一个元素为轴
int pivot = array[p_pos];
for (int i = low + 1; i <= high; i++) {
if (array[i] < pivot) {
p_pos++;
swap(array, p_pos, i);
}
}
swap(array, low, p_pos);
return p_pos;
}
/**
* 快速排序实现
* @param array
* @param low
* @param high
*/
public static void quickSort(int array[], int low, int high) {
if (low < high) {
int pivot = partition(array, low, high);
quickSort(array, low, pivot - 1);
quickSort(array, pivot + 1, high);
}
}
子类的static方法和父类有同名、同参数的static方法，但他们之间没什么覆盖、继承的关系，你调用的 时候看是用那个类名引用了，用子类的类名就调用子类的static方法，用父类类名就调用父类的static方法。 static 顾名思义，就是静态的，他是方法的，他属于这个类，由于是类的方法，他可以直接引用类名来引用方法，他既不能被子类覆盖，也不能被子类继承。简单的说，他是在编译的时候就和类帮定在一起了，不能被运行时动态加载。
java中多种方式读文件
一、多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
public class ReadFromFile {
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
* @param fileName 文件的名
*/
public static void readFileByBytes(String fileName){
File file = new File(fileName);
InputStream in = null;
try {
System.out.println("以字节为单位读取文件内容，一次读一个字节：");
// 一次读一个字节
in = new FileInputStream(file);
int tempbyte;
while((tempbyte=in.read()) != -1){
System.out.write(tempbyte);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
try {
System.out.println("以字节为单位读取文件内容，一次读多个字节：");
//一次读多个字节
byte[] tempbytes = new byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//读入多个字节到字节数组中，byteread为一次读入的字节数
while ((byteread = in.read(tempbytes)) != -1){
System.out.write(tempbytes, 0, byteread);
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null){
try {
in.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
* @param fileName 文件名
*/
public static void readFileByChars(String fileName){
File file = new File(fileName);
Reader reader = null;
try {
System.out.println("以字符为单位读取文件内容，一次读一个字节：");
// 一次读一个字符
reader = new InputStreamReader(new FileInputStream(file));
int tempchar;
while ((tempchar = reader.read()) != -1){
//对于windows下，rn这两个字符在一起时，表示一个换行。
//但如果这两个字符分开显示时，会换两次行。
//因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。
if (((char)tempchar) != 'r'){
System.out.print((char)tempchar);
}
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
System.out.println("以字符为单位读取文件内容，一次读多个字节：");
//一次读多个字符
char[] tempchars = new char[30];
int charread = 0;
reader = new InputStreamReader(new FileInputStream(fileName));
//读入多个字符到字符数组中，charread为一次读取字符数
while ((charread = reader.read(tempchars))!=-1){
//同样屏蔽掉r不显示
if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){
System.out.print(tempchars);
}else{
for (int i=0; i<charread; i++){
if(tempchars[i] == 'r'){
continue;
}else{
System.out.print(tempchars[i]);
}
}
}
}
} catch (Exception e1) {
e1.printStackTrace();
}finally {
if (reader != null){
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
* @param fileName 文件名
*/
public static void readFileByLines(String fileName){
File file = new File(fileName);
BufferedReader reader = null;
try {
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
//一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null){
//显示行号
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null){
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 随机读取文件内容
* @param fileName 文件名
*/
public static void readFileByRandomAccess(String fileName){
RandomAccessFile randomFile = null;
try {
System.out.println("随机读取一段文件内容：");
// 打开一个随机访问文件流，按只读方式
randomFile = new RandomAccessFile(fileName, "r");
// 文件长度，字节数
long fileLength = randomFile.length();
// 读文件的起始位置
int beginIndex = (fileLength > 4) ? 4 : 0;
//将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes = new byte[10];
int byteread = 0;
//一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
//将一次读取的字节数赋给byteread
while ((byteread = randomFile.read(bytes)) != -1){
System.out.write(bytes, 0, byteread);
}
} catch (IOException e){
e.printStackTrace();
} finally {
if (randomFile != null){
try {
randomFile.close();
} catch (IOException e1) {
}
}
}
}
/**
* 显示输入流中还剩的字节数
* @param in
*/
private static void showAvailableBytes(InputStream in){
try {
System.out.println("当前字节输入流中的字节数为:" + in.available());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}
二、将内容追加到文件尾部
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 将内容追加到文件尾部
*/
public class AppendToFile {
/**
* A方法追加文件：使用RandomAccessFile
* @param fileName 文件名
* @param content 追加的内容
*/
public static void appendMethodA(String fileName,
String content){
try {
// 打开一个随机访问文件流，按读写方式
RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
// 文件长度，字节数
long fileLength = randomFile.length();
//将写文件指针移到文件尾。
randomFile.seek(fileLength);
randomFile.writeBytes(content);
randomFile.close();
} catch (IOException e){
e.printStackTrace();
}
}
/**
* B方法追加文件：使用FileWriter
* @param fileName
* @param content
*/
public static void appendMethodB(String fileName, String content){
try {
//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer = new FileWriter(fileName, true);
writer.write(content);
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
String content = "new append!";
//按方法A追加文件
AppendToFile.appendMethodA(fileName, content);
AppendToFile.appendMethodA(fileName, "append end. n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
//按方法B追加文件
AppendToFile.appendMethodB(fileName, content);
AppendToFile.appendMethodB(fileName, "append end. n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
}
}
分享到：
发表评论
相关推荐
2. **面试总结.txt或.md**：这是一个文本文件，可能是求职者在面试后对整个过程的记录和反思，包括对面试问题的回答情况、个人表现的评价、面试官的反应以及从中吸取的经验教训。 3. **职位需求与匹配.pdf**：这...
2. **内存管理**： - 引用计数（ARC）：理解引用计数的工作原理，如何避免循环引用和强引用陷阱。 - Weak和Unowned：知道何时使用它们来解决内存问题。 - Swift中的Deinit和析构函数：了解它们在什么时候被调用...
java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 java面试100题及面试技巧总结，自己整理总结的java面试技巧及面试题。 ...
Java面试总结面试总结PDF
JavaOOP面试题 Java集合/泛型面试题 Java异常面试题 Java中的IO与NIO面试题 Java反射面试题 Java序列化面试题 Java注解面试题 多线程&并发面试题 JVM面试题 Mysql面试题 Redis面试题 Memcached面试题 MongoDB面试题 ...
Java面试大全涵盖了大量的技术知识点，这些内容通常会出现在各大公司的面试过程中。为了帮助你更好地准备，以下是基于描述中提到的“31个文档”可能涉及的一些核心Java面试知识点的详细阐述： 1. **基础概念**：...
这份"10万字面试总结Java.pdf"涵盖了Java基础知识、JVM、Spring框架、并发编程、Linux、Dubbo、Mybatis、Springcloud、Spring Boot、消息队列和Zookeeper等多个核心主题，旨在帮助Java开发者全面准备面试。...
在进行《我想进大厂》的面试总结时，我们首先要了解面试对于求职者和招聘方的重要性。面试不仅仅是一个考核和选择的过程，它也反映了求职者的职业素养、技术能力、沟通技巧和解决问题的能力。而对于面试官而言，面试...
陈涛后端面试总结 这篇文章总结了数字IC后端的一些重要问题，涵盖了电源走线的选择、交替路由的应用、线间干扰的解决、标准单元延迟的影响因素、禁止使用库中某些单元、wire load model的类型、延迟模型的类型、...
苍穹外卖项目——面试问题总结.md
Java面试总结面试宝典.xmind
"面试SQL经典总结"这个主题，通常涵盖了SQL的基础概念、常用查询语句、高级功能以及在实际面试中可能遇到的问题。下面，我们将深入探讨这些关键知识点。 1. SQL基础： - 数据库模型：了解关系型数据库的基本原理，...
本文档是关于软件工程师程序员Java面试题和答案的总结，涵盖了Java语言的特点、面向对象和面向过程的区别、基本数据类型、标识符的命名规则、instanceof关键字的作用、Java自动装箱与拆箱等知识点。 一、Java语言的...
大数据面试复习---Java基础---集合类、多线程、JVM 大数据面试复习----常问问题分析 ...大数据面试复习----人事面试常问的问题总结 大数据面试复习----数据结构和算法+其他 大数据面试复习---项目架构流图串讲
2020年上海JAVA开发工程师面试总结
### 阿里面试总结及答案 #### 一、Java事件机制 Java事件机制是Swing框架中的核心组件之一，它允许程序响应用户输入或其他事件。该机制主要包括三个方面：事件、事件监听器以及事件源。 - **事件**：通常继承自`...
阿里巴巴面试总结DOC版 本资源摘要信息主要总结了阿里巴巴面试中的问题和答案，涵盖了 Java 编程语言、设计模式、JVM 内存模型、ClassLoader 结构、UML 模型图、OSGi 框架、Spring 框架、iBatis 框架、Java 序列化...
零跑汽车一面 ...2. **面试经验**： - **自我介绍**：准备一个简洁明了的自我介绍，突出你的专业背景和为什么适合这个岗位。 - **项目介绍**：选择一个你最有成就感的项目详细介绍，包括你的角色、项目难点、
2. **数据结构与算法**：面试中常见的数据结构有数组、链表、栈、队列、树、图等，而算法则涉及排序（如快速排序、归并排序）、查找（如二分查找）、递归等。面试官可能会让你现场编写或解释算法的实现。 3. **多...
"cocos2d-x面试题总结" 本篇总结了cocos2d-x面试的常见问题，涵盖了C++基础知识、cocos2d-x特性和实现机理等方面。下面是根据给定的文件信息生成的相关知识点： 一、C++基础知识 1. C和C++的区别：C++在C的基础上...