收藏列表
| 标题 | 标签 | 来源 | |
| java面试——java控制台打印三角形总结 | 三角形 | java面试——java控制台打印三角形总结 | |
java面试——java控制台打印三角形总结
关键字: 三角形
在公司面试中经常碰到的问题，我总结了一下，大概就这么多，其实挺简单的，但是在面试的时候没有IDE的帮助，如果想一次性写对，对我本人来说还是有点难度的，不是不知道思路，而是很有可能在初始化变量i ,j的时候，还是有是否是等于的时候容易出错，细心点应该没什么问题
Java代码
package com.xyq.demo;
public class Triangle {
/**
* @param args
*/
public static void main(String[] args) {
a(); //打印正等腰三角
b(); //打印倒等腰三角
c(); //打印直边靠左正直角三角
d(); //打印直边靠右正直角三角
e(); //打印直边靠左倒直角三角
f(); //打印直边靠右倒直角三角
g(); //打印底边靠左钝角角三角
h(); //打印底边靠右钝角角三角
}
/**
* 作用:打印正等腰三角
*/
public static void a(){
System.out.println("打印正等腰三角");
int i ,j;
for(i=1;i<=5;i++){
for(j=5;j>i;j--){
System.out.print(" ");
}
for(j=0;j<i*2-1;j++){
System.out.print("*");
}
System.out.println();
}
}
/**
* 打印倒等腰三角
*/
public static void b(){
System.out.println("打印倒等腰三角");
int i ,j ;
for(i=1;i<=5;i++){
for(j=1;j<i;j++){
System.out.print(" ");
}
for(j=10;j>i*2-1;j--){
System.out.print("*");
}
System.out.println();
}
}
/**
* 打印直边靠左正直角三角
*/
public static void c(){
System.out.println("打印直边靠左正直角三角");
int i ,j ;
for(i=1;i<=5;i++){
for(j=0;j<i;j++){
System.out.print("*");
}
System.out.println();
}
}
/**
* 打印直边靠右正直角三角
*/
public static void d(){
System.out.println("打印直边靠右正直角三角");
int i ,j;
for(i=1;i<=5;i++){
for(j=5;j>i;j--){
System.out.print(" ");
}
for(j=0;j<i;j++){
System.out.print("*");
}
System.out.println();
}
}
/**
* 打印直边靠左倒直角三角
*/
public static void e(){
System.out.println("打印直边靠左倒直角三角");
int i ,j;
for(i=1;i<=5;i++){
for(j=5;j>=i;j--){
System.out.print("*");
}
System.out.println();
}
}
/**
* 打印直边靠右倒直角三角
*/
public static void f(){
System.out.println("打印直边靠右倒直角三角");
int i ,j;
for(i=1;i<=5;i++){
for(j=1;j<i;j++){
System.out.print(" ");
}
for(j=5;j>=i;j--){
System.out.print("*");
}
System.out.println();
}
}
/**
* 打印底边靠左钝角角三角
*/
public static void g(){
System.out.println("打印底边靠左钝角角三角");
int i ,j ;
for(i=1;i<=5;i++){
for(j=0;j<i;j++){
System.out.print("*");
}
System.out.println();
}
for(i=1;i<5;i++){
for(j=5;j>i;j--){
System.out.print("*");
}
System.out.println();
}
}
/**
* 打印底边靠右钝角角三角
*/
public static void h(){
System.out.print("打印底边靠右钝角角三角");
int i,j;
for(i=0;i<=5;i++){
for(j=5;j>i;j--){
System.out.print(" ");
}
for(j=0;j<i;j++){
System.out.print("*");
}
System.out.println();
}
for(i=1;i<5;i++){
for(j=0;j<i;j++){
System.out.print(" ");
}
for(j=5;j>i;j--){
System.out.print("*");
}
System.out.println();
}
}
}
|
|||
| java面试——单例模式 | 单例模式 | java面试——单例模式 | |
java面试——单例模式
关键字: singleton
在进公司java面试时，容易考到的题目，singleton模式的特点并写一个singleton。
单例模式有以下的特点：
1.单例类只可有一个实例。
2.单例类必须自己创建自己这惟一的实例。
3.单例类必须给所有其他对象提供这一实例。
Java代码
package com.xyq.demo;
public class Singleton {
private static Singleton singleton;
private Singleton() {
};
public static Singleton getInstance() {
if (singleton == null)
singleton = new Singleton();
return singleton;
}
}
// 测试类
class singletonTest {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
if (s1 == s2)
System.out.println("s1 is the same instance with s2");
else
System.out.println("s1 is not the same instance with s2");
}
}
package com.xyq.demo;
public class Singleton {
private static Singleton singleton;
private Singleton() {
};
public static Singleton getInstance() {
if (singleton == null)
singleton = new Singleton();
return singleton;
}
}
// 测试类
class singletonTest {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
if (s1 == s2)
System.out.println("s1 is the same instance with s2");
else
System.out.println("s1 is not the same instance with s2");
}
} 输出: s1 is the same instance with s2
恶汉式单例类
Java代码
package com.xyq.demo;
public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
// 测试类
class singletonTest {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
if (s1 == s2)
System.out.println("s1 is the same instance with s2");
else
System.out.println("s1 is not the same instance with s2");
}
}
package com.xyq.demo;
public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
// 测试类
class singletonTest {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
if (s1 == s2)
System.out.println("s1 is the same instance with s2");
else
System.out.println("s1 is not the same instance with s2");
}
}
输出: s1 is the same instance with s2
懒汉式单例类
Java代码
package com.xyq.demo;
public class Singleton {
private static Singleton instance = null;
/**
* 私有的默认构造子，保证外界无法直接实例化
*/
private Singleton() {
}
/**
* 静态工厂方法，返还此类的惟一实例
*/
synchronized public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
// 测试类
class singletonTest {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
if (s1 == s2)
System.out.println("s1 is the same instance with s2");
else
System.out.println("s1 is not the same instance with s2");
}
}
package com.xyq.demo;
public class Singleton {
private static Singleton instance = null;
/**
* 私有的默认构造子，保证外界无法直接实例化
*/
private Singleton() {
}
/**
* 静态工厂方法，返还此类的惟一实例
*/
synchronized public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
// 测试类
class singletonTest {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
if (s1 == s2)
System.out.println("s1 is the same instance with s2");
else
System.out.println("s1 is not the same instance with s2");
}
}
输出: s1 is the same instance with s2
我写的这些仅适用于公司面试，如果要想好好学习设计模式，得全面的看看这方面的资料
|
|||
| java面试——快速排序 | 数据结构 | java面试——快速排序 | |
java面试——快速排序
关键字: 数据结构
基本思想
快速排序对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
算法过程
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是：
1）设置两个变量I、J，排序开始的时候：I=1，J=N;
2）以第一个数组元素作为关键数据，赋值给X，即 X=A[0]；
3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于X的值，让该值与X交换；
4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于X的值，让该值与X交换；
5）重复第3、4步，直到 I=J；
例如：待排序的数组A的值分别是：（初始关键数据：X=3）
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]
3 1 5 4 2
根据（3）从右往左找，找到第一个小于X的值为2（2<3） 进行与X的交换，
进行第一次交换后： 2 1 5 4 3 ，此时J=3
根据（4）从左往右找，找到第一个大于X的值为5（5>3） 进行与X的交换，
进行第二次交换后：2 1 3 4 5 ， 此时I=2
再执行第三步的时候就发现I=J，从而结束一躺快速排序，那么经过一趟快速排序之后的结果是：
2 1 3 4 5，即所以大于3的数全部在3的右边，所以小于3的数全部在3的左边。
快速排序就是递归调用此过程——在以3为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列。
初始状态 {3 1 5 4 2}
进行一次快速排序之后划分为 {2 1} 3{4 5}
分别对前后两部分进行快速排序 {2 1} 经第三步和第四步交换后变成 {1 2} 完成排序。
{4 5} 经第三步和第四步交换后变成 {4 5} 完成排序。
JAVA算法
Java代码
/**
* 工程：sort
* 包名：com.xyq.demo
* 文件：QuitSort .java
* 作者：xiatiaohcx
* 时间：Apr 1, 2009 10:31:30 AM
*/
package com.xyq.demo;
/**
* @author xiatiaohcx
*
* 作用：快速排序
*/
public class QuitSort {
public static void main(String[] args) {
int[] nums = { 3,1,5,4,2 };
quickSort(nums, 0, nums.length - 1);
for (int i = 0; i < nums.length; ++i) {
System.out.print(nums[i] + ",");
}
System.out.println("");
}
public static void quickSort(int[] a, int low, int hight) {
int left = low;
int right = hight;
if (left >= right)
return;
boolean flag = true;
while (left != right) {
if (a[left] > a[right]) {
int temp = a[left];
a[left] = a[right];
a[right] = temp;
flag = (flag == true) ? false : true;
}
if (flag)
right--;
else
left++;
}
left--;
right++;
quickSort(a, low, left);
quickSort(a, right, hight);
}
}
/**
* 工程：sort
* 包名：com.xyq.demo
* 文件：QuitSort .java
* 作者：xiatiaohcx
* 时间：Apr 1, 2009 10:31:30 AM
*/
package com.xyq.demo;
/**
* @author xiatiaohcx
*
* 作用：快速排序
*/
public class QuitSort {
public static void main(String[] args) {
int[] nums = { 3,1,5,4,2 };
quickSort(nums, 0, nums.length - 1);
for (int i = 0; i < nums.length; ++i) {
System.out.print(nums[i] + ",");
}
System.out.println("");
}
public static void quickSort(int[] a, int low, int hight) {
int left = low;
int right = hight;
if (left >= right)
return;
boolean flag = true;
while (left != right) {
if (a[left] > a[right]) {
int temp = a[left];
a[left] = a[right];
a[right] = temp;
flag = (flag == true) ? false : true;
}
if (flag)
right--;
else
left++;
}
left--;
right++;
quickSort(a, low, left);
quickSort(a, right, hight);
}
} 呵呵，这篇文章是我的第一个开篇，写的有点垃圾，大部分都是从baidu上搜出来的，不过是自己整理的，javaeye让标 明是否原创，郁闷，支持自己一个，写个原吧
|
|||
| java面试——逆序打印 | 逆序打印 | java面试——逆序打印 | |
java面试——逆序打印
关键字: 逆序打印
公司程序员面试经常碰到的题
1.String的subString()方法
Java代码
package com.xyq.demo;
public class Reverse {
public static void main(String[] args) {
String s = "残花百力无风东,难亦别难时见相";
int len = s.length();
String reverse = "";
for (int i = len; i > 0; i--)
reverse += s.substring(i - 1, i);
System.out.print(reverse);
}
}
package com.xyq.demo;
public class Reverse {
public static void main(String[] args) {
String s = "残花百力无风东,难亦别难时见相";
int len = s.length();
String reverse = "";
for (int i = len; i > 0; i--)
reverse += s.substring(i - 1, i);
System.out.print(reverse);
}
} 输出:相见时难别亦难,东风无力百花残
2.StringBuffer的reverse()方法
Java代码
package com.xyq.demo;
import java.util.Scanner;
public class Reverse {
public static void main(String[] args) {
String str;
System.out.println("请输入:");
Scanner scan=new Scanner(System.in);
str=scan.nextLine();
str=(new StringBuffer(str).reverse()).toString();
System.out.println(str);
}
}
package com.xyq.demo;
import java.util.Scanner;
public class Reverse {
public static void main(String[] args) {
String str;
System.out.println("请输入:");
Scanner scan=new Scanner(System.in);
str=scan.nextLine();
str=(new StringBuffer(str).reverse()).toString();
System.out.println(str);
}
} 请输入:
123
321
3.禁止使用String,StringBuffer,Integer (整数逆序打印)
Java代码
package com.xyq.demo;
public class Reverse {
public static void main(String[] args) {
output(103658);
}
public static void output(int num) {
int temp = 0;
while (num > 9) {
temp = num % 10;
System.out.print(temp);
num = (int) (num / 10);
}
System.out.print(num);
}
}
package com.xyq.demo;
public class Reverse {
public static void main(String[] args) {
output(103658);
}
public static void output(int num) {
int temp = 0;
while (num > 9) {
temp = num % 10;
System.out.print(temp);
num = (int) (num / 10);
}
System.out.print(num);
}
} 输出:856301
4.栈
Java代码
package com.xyq.demo;
import java.util.Stack;
public class Reverse {
public static void main(String[] args) {
reverseStr("103658");
}
@SuppressWarnings("unchecked")
public static void reverseStr(String s) {
Stack myStack = new Stack();
for (int i = 0; i <= s.length() - 1; i++) {
myStack.push(String.valueOf(s.charAt(i)));
}
while (!myStack.empty()) {
System.out.print((String) myStack.pop());
}
}
}
package com.xyq.demo;
import java.util.Stack;
public class Reverse {
public static void main(String[] args) {
reverseStr("103658");
}
@SuppressWarnings("unchecked")
public static void reverseStr(String s) {
Stack myStack = new Stack();
for (int i = 0; i <= s.length() - 1; i++) {
myStack.push(String.valueOf(s.charAt(i)));
}
while (!myStack.empty()) {
System.out.print((String) myStack.pop());
}
}
} 输出:856301
5.数组
Java代码
package com.xyq.demo;
public class Reverse {
public static void main(String[] args) {
System.out.println(f("103658"));
}
public static String f(String s) {
char[] c = s.toCharArray();
char[] temp = new char[c.length];
for (int i = 0, j = c.length - 1; i < c.length; i++, j--) {
temp[j] = c[i];
}
return new String(temp, 0, temp.length);
}
}
|
|||
| 各种数组排序方法总结 | 数据结构，java算法 | 各种数组排序方法总结 | |
前一段时间面试，经常遇到有关排序的面试题，闲了无事，将各种排序方法用java写了一下。
代码如下：
Java代码
import java.lang.Math;
import java.util.Random;
/**
* 排序
*
* @author javajack
*/
public class OrderTest {
public static void main(String args[]) {
OrderTest.ExecOrder(2);
}
/**
* 交换值，交换数组的两个值
* @param array
* @param i
* @param j
*/
private static void swap(int[] array,int i, int j)
{
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
/**
*
* @param method
* 1为升序，2为降序
*/
public static void ExecOrder(int method) {
int[] array = null;
array = initArray(10, 210, 10);
//int[] orderarray = bubbleOrder(array,method);
int[] orderarray = doubleBubbleOrder(array,method);
//int[] orderarray = insertOrder(array, method);
//int [] orderarray = quickOrder(array,method);
//int[] orderarray = selectOrder(array, method);
for (int i = 0; i < orderarray.length; i++) {
System.out.println(orderarray[i]);
}
}
/**
* 取随机数据，初始化一个数组
*
* @param min
* 随机数的最小值
* @param max
* 最大值
* @param size
* 取得随机数的数量
* @return
*/
public static int[] initArray(int min, int max, int size) {
int[] init = new int[size];
for (int i = 0; i < size; i++) {
Random ra = new Random();
init[i] = min + (int) (Math.random() * (max - min + 1));
System.out.println(i + "-------" + init[i]);
}
return init;
}
/**
* 交换排序方法
* 原理：依次交换值
* @param array
* @return
*/
public static int[] convertOrder(int[] array, int method) {
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++)
{
if (method==2)
{
if (array[i] < array[j])
swap(array,i,j);
}else if (method == 1) {
if (array[i] > array[j])
swap(array,i,j);
}
}
}
return array;
}
/**冒泡排序方法
* 原理：从最后一个开始将小的或大的逐渐冒出
* @param array
* @param method
* @return
*/
public static int[] bubbleOrder(int[] array,int method)
{
for(int i=0;i<array.length;i++)
{
for (int j=array.length -1 ;j>i;j--)
{
if (method==2)
{
if (array[i] < array[j])
swap(array,i,j);
}else if (method==1)
if (array[i] > array[j])
swap(array,i,j);
}
}
return array;
}
/**
* 双向冒泡排序
* 原理：类似于冒泡排序，只不过是双向的
* @param array
* @param method
* @return
*/
public static int[] doubleBubbleOrder(int[] array,int method)
{
int left = 0;
int right = array.length -1 ;
while (left < right)
{
for(int i=left;i<=right;i++)
{
if (method==1)
{
if (array[left] > array[i])
swap(array,left,i);
}else
{
if (array[left] < array[i])
swap(array,left,i);
}
}
for (int i=left+1;i<=right;i++)
{
if (method==1)
{
if (array[right] < array[i])
swap(array,right,i);
}else
{
if (array[right] > array[i])
swap(array,right,i);
}
}
left++;
right--;
}
return array;
}
/**
* 快速排序方法，运用到递归
* 排序原理：随机找到一个值，然后以此值大小进行分为两个数组，大的放左边，小的放右边，
* 然后再对左右两侧的数据依次排序根据
* @param array
* @param method
* @return
*/
public static int[] quickOrder(int[] array, int method)
{
quickDeal(array,0,array.length - 1,method);
return array;
}
/**
*
* @param array
* @param begin
* 开始位置
* @param end
* 结束位置
*/
private static void quickDeal(int[] array, int begin, int end,int method) {
if (end > begin) {
int pos = begin + (int) (Math.random() * (end - begin + 1)); // 计算分隔位置
int posvalue = array[pos]; // 取得分隔位置的值
swap(array,pos,end); //将posvalue放到最end的位置
pos=begin; //初始化pos
for (int i=begin; i < end; i++) {
if (method==1)
{
if (array[i] < posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
swap(array,pos,i);
pos++; //移动后pos增1
}
}else if(method == 2)
{
if (array[i] > posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
swap(array,pos,i);
pos++; //移动后pos增1
}
}
}
swap(array,pos,end); //end位置的值前移
quickDeal(array,begin,pos -1,method);
quickDeal(array,pos+1,end,method);
}
}
/**
* 插入排序方法
* 排序原理：抽出一个数，做为排序基序列，然后依次抽出其它数与，与此序列中的数进行比较，放入合适的位置
* @param array
* @param method
* @return
*/
public static int[] insertOrder(int[] array, int method) {
for (int i = 1; i < array.length; i++) {
if (method == 1) {
if (array[i - 1] > array[i]) {
int tmp = array[i]; //
int j = i - 1;
do {
array[j + 1] = array[j];
j--;
} while (j >= 0 && tmp < array[j]); //当j>=0并且 当前值大于数据中j位置的值时移动
array[j + 1] = tmp; //插入排序值
}
} else if (method == 2) {
if (array[i - 1] < array[i]) {
int tmp = array[i];
int j = i - 1;
do {
array[j + 1] = array[j];
j--;
} while (j >= 0 && tmp > array[j]);
array[j + 1] = tmp;
}
}
}
return array;
}
/**
* 选择排序方法
* 排序原理：每次选择一个最大的或最小的数放到已排序序列中
* @param array
* @param method
* @return
*/
public static int[] selectOrder(int[] array,int method)
{
for (int i=0;i<array.length - 1;i++)
{
int tmp = array[i];
int pos = i+1; //记录大值或小值的位置
for (int j=i+1;j<array.length;j++)
{
if (method==1)
{
if (array[j]<tmp)
{
tmp = array[j];
pos= j ;//记录大值或小值的位置
}
}else if (method==2)
{
if (array[j]>tmp)
{
tmp = array[j];
pos= j ;//记录大值或小值的位置
}
}
}
if (tmp != array[i])
swap(array,i,pos); //不相同时交换
}
return array;
}
}
|
|||
| java冒泡排序 | 数据结构，java算法 | ||
基本概念
冒泡排序的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再大于第2个数），将小数放前，大数放后，一直比较到最小数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最小数。如此下去，直至最终完成排序。
由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。
用二重循环实现，外循环变量设为i，内循环变量设为j。外循环重复9次，内循环依次重复9，8，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i, j的值依次为1,2,...10-i。
第一种
public class BubbleSort {
/**
* @param args
*/
public static void main(String[] args) {
int[] sort = {5,9,4,3,8,6};
bubbleSort(sort);
}
public static void bubbleSort(int[] sort)
{
int temp;
for(int i = 0; i<sort.length-1;i++)
{
for (int j = 0; j < sort.length-i-1; j++) {
if(sort[j]>sort[j+1])
{
temp = sort[j];
sort[j] = sort[j+1];
sort[j+1] = temp;
}
}
}
for (int i = 0; i < sort.length; i++) {
System.err.print(sort[i] + " ");
}
}
}
第二种
public class BubbleSort {
public static void sort(int[] data) {
int temp;
for (int i = 0; i < data.length; i++) {
for (int j = data.length - 1; j > i; j--) {
if (data[i] > data[j]) {
temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
}
}
public static void main(String[] args) {
int[] a = { 4, 2, 3, 1, 5 };
sort(a);
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
}
}
|
|||