测试

最新推荐文章于 2024-12-19 10:11:44 发布

hanshanyeyu

最新推荐文章于 2024-12-19 10:11:44 发布

阅读量353

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/hanshanyeyu/article/details/52608134

1. 单例模式

单例模式用来保证系统中的一个类只有一个实例

单例类的构造函数必须私有

同时单例类必须提供一个全局访问点

public class Test {
	private Test(){}
	private static Test uniqueInstance = new Test();
	public static Test getInstance(){
		return uniqueInstance; 
	}

}

2. 实现二叉树排序

@1 如果二叉树左子树不为空，那么所有左子树上所有的节点小于它的根节点

@2 如果右子树不为空，那么所有右子树所有的节点大于它的根节点

@3 左右子树也分别是二叉树排序

package package2;

public class BinaryTree {

int data;      //根节点数据
BinaryTree left;    //左子树
BinaryTree right;   //右子树

public BinaryTree(int data)    //实例化二叉树类
{
  this.data = data;
  left = null;
  right = null;
}

public void insert(BinaryTree root,int data){     //向二叉树中插入子节点
  if(data>root.data)                               //二叉树的左节点都比根节点小
  {
   if(root.right==null){
    root.right = new BinaryTree(data);
   }else{
    this.insert(root.right, data);
   }
  }else{                                          //二叉树的右节点都比根节点大
   if(root.left==null){
    root.left = new BinaryTree(data);
   }else{
    this.insert(root.left, data);
   }
  }
}

}

当建立好二叉树类后可以创建二叉树实例，并实现二叉树的先根遍历，中根遍历，后根遍历，代码如下：

package package2;

public class BinaryTreePreorder {

public static void preOrder(BinaryTree root){  //先根遍历
  if(root!=null){
   System.out.print(root.data+"-");
   preOrder(root.left);
   preOrder(root.right);
  }
}

public static void inOrder(BinaryTree root){     //中根遍历

  if(root!=null){
   inOrder(root.left);
   System.out.print(root.data+"--");
   inOrder(root.right);
  }
}

public static void postOrder(BinaryTree root){    //后根遍历

  if(root!=null){
   postOrder(root.left);
   postOrder(root.right);
   System.out.print(root.data+"---");
  }
}

public static void main(String[] str){
  int[] array = {12,76,35,22,16,48,90,46,9,40};
  BinaryTree root = new BinaryTree(array[0]);   //创建二叉树
  for(int i=1;i<array.length;i++){
   root.insert(root, array[i]);       //向二叉树中插入数据
  }
  System.out.println("先根遍历：");
  preOrder(root);
  System.out.println();
  System.out.println("中根遍历：");
  inOrder(root);
  System.out.println();
  System.out.println("后根遍历：");
  postOrder(root);

3.Stringbuffer 和 stringbuilder的区别

StringBuffer 和 StringBuilder类都表示内容可以被修改的字符串，StringBuilder是线程不安全的，运行效率高

如果一个字符串变量是定义在方法里面的，这种情况只能有一个线程访问，不存在安全因素则用StringBulider.如果

要在类里面定义成员变量，并且这个类的实例对象会再多线程环境下使用，那么最好用StringBuffer

4.HashMap 和 HashTable的区别，那个是线程安全的，不安全的如何让他安全

Hashtable是线程安全的，也就是说是同步的，速度慢，不可以存放null键null值，已被hashmap取代

HashMap是线程序不安全的，不是同步的，可以存放放null键null值，通过hashset原理保证键唯一

5. list set的区别，那个是有序的

List(inteface)

次序是List的最重要特点,它确保维护元素特定的顺序.
－－ArrayList 允许对元素快速随机访问.
－－LinkedList 对顺序访问进行优化,向List中间插入与移除的开销并不大，具有addFrist(),addLast(),getFirst,getLast,removeFirst和removeLast().这些方法使得LinkedList可当作堆栈／队列／双向队列.

Set(inteface)

存入Set的每个元素必须唯一，不保证维护元素的次序.加入Set的Object必须定义equals()方法
－－HashSet　为快速查找而设计的Set，存入HashSet对象必须定义hashCode().
－－TreeSet 保护次序的Set，使用它可以从Set中提取有序序列.
－－LinkedHashSet　　具有HashSet的查询速度，且内部使用链表维护元素的次序.
它们之间的存储方式不一样：
TreeSet采用红黑树的树据结构排序元素.
HashSet采用散列函数，这是专门为快速查询而设计的.
LinkedHashSet内部使用散列以加快查询速度，同时使用链表维护元素的次序.

使用HashSet/TreeSet时，必须为类定义equals()；而HashCode()是针对HashSet，作为一种编程风格，当覆盖equals()的时候，就应该同时覆盖hashCode().

6.ArrayList Ventor的区别

7java注释

8泛型

9.反射

10.Java的垃圾回收机制：按代回收

11java的多线程是如何实现的

12Thread 的start 和run的区别

13.java 文件的io 读写

14.常见的Exception

RunTimeException ：NullPointerException ArrayIndexOutOfBoundsException ClassCastException IOException ArithmeticException(算数运行异常)

FileNotFoundException

IllegaArgumentException

15经常用的包都有哪些

java.lang java.uitl date sql junit

16. Object类默认都实现了哪些方法

1．clone方法

保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。

2．getClass方法

final方法，获得运行时类型。

3．toString方法

该方法用得比较多，一般子类都有覆盖。

4．finalize方法

该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

5．equals方法

该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。

6．hashCode方法

该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。

一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。

7．wait方法

wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。

调用该方法后当前线程进入睡眠状态，直到以下事件发生。

（1）其他线程调用了该对象的notify方法。

（2）其他线程调用了该对象的notifyAll方法。

（3）其他线程调用了interrupt中断该线程。

（4）时间间隔到了。

此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。

8．notify方法

该方法唤醒在该对象上等待的某个线程。

9．notifyAll方法

该方法唤醒在该对象上等待的所有线程。

17 工作中都用到了哪些设计模式

18 单例模式如何写

public class Test {
	private Test(){}
	private static Test uniqueInstance = new Test();
	public static Test getInstance(){
		return uniqueInstance; 
	}

}

19 对大文件大数据的处理

20 工作中遇到哪些困难，最后怎么解决的

21 从一个文本文件中找出出现次数最多的一个字，并统计个数

public void testNumAccount(){
    File file = new File("F:\\TEST.txt");
    BufferedReader reader = null;
    try {
        String value="";
        String newValue ="";
        reader= new BufferedReader(new FileReader(file));
        while ((newValue =reader.readLine())!= null){
            value =newValue +value;
        }
        System.out.println(value);
        char []args = value.toCharArray();
        TreeMap<Character,Integer> map = new TreeMap<Character,Integer>();
        for(int i=0;i<args.length;i++)
            if (map.containsKey(args[i])) {
                int account = map.get(args[i]) + 1;
                map.put(args[i], account);s
            }else {
                map.put(args[i],1);
            }

            Set<Map.Entry<Character,Integer>> set = map.entrySet();
            Iterator<Map.Entry<Character,Integer>> iter= set.iterator();
            int account = 0;
        char output='m';
        List list = new ArrayList();
            while (iter.hasNext()){
                Map.Entry<Character,Integer> map_a = iter.next();
                char k = map_a.getKey();
                int m = map_a.getValue();
                if (m>account){
                    account =m;
                     output =k;
                }
            }
        System.out.println(output);
    } catch (IOException e) {
        System.out.println("文件读取错误");
    }finally {
        if (reader!=null){
            try {
                reader.close();
            } catch (IOException e) {
                System.out.println("文件关闭错误");
            }
        }
    }
}

22.有一个字符串String="dsfdfddfklkdfklsdfoepffrddlkfl,找出出现最多的字母和次数

public class listset {
    public static void main(String[] args) {
        String input ="dsfdfddfklkdfklsdfoepffrddlkfl";
        new listset().dostring(input);

    }

    private void dostring(String input) {
        char[] chars = input.toCharArray();
        ArrayList list = new ArrayList();
        TreeSet set = new TreeSet();
        for(int i=0;i<chars.length;i++){
//            list.add(chars[i]);
            list.add(String.valueOf(chars[i]));
            set.add(String.valueOf(chars[i]));
        }
        Collections.sort(list);
        System.out.println(list);
        System.out.println(set);

        StringBuffer sb = new StringBuffer();
        for(int j=0;j<list.size();j++){

            sb.append(list.get(j));

        }
        input = sb.toString();
        System.out.println(input);
        System.out.println();

        int max =0;
        String maxString ="";
        ArrayList maxlist = new ArrayList();
        Iterator iter= set.iterator();
        while (iter.hasNext()){
            String os = (String)iter.next();
            int begin = input.indexOf(os);
            int end = input.lastIndexOf(os);
            if(end-begin+1>max){
                max= end-begin+1;
                maxString = os;
                maxlist.add(os);
            }else if(end-begin+1==max){
                maxlist.add(os);

            }
        }
        for(int n=0;n<maxlist.size();n++){
            System.out.println(maxlist.get(n));
            System.out.println(max);

        }
    }
}

22. 给出一个随机数492，写一个方法实现 4+9+2

方法1

   int num = 492; 

		int result = 0; 

		while(true){ 

		    if(num>10){ 

		        result = result + num%10; 

		        num = num/10; 

		    }else{ 

		        result = result + num; 

		        break; 

		    } 

		} 

		System.out.println(result);

方法2：

public class Calsum {


	public static void main(String[] args) {

		
		int i,n=0,j=100 ;
		int s=492;

		for (int k=0;k<3;k++){
		     i= s / j;
		    s=s%j;  
		    j=j/10;
		    n+=i;
		    
		}
		System.out.println(n);	System.out.println(n);

快速排序

public class Demo3 {

    private static void QuickSort(int a[]) {

        sort(a,0,a.length-1);
    }
private static void sort(int[] k,int low,int high) {
    if(low>high){
        return ;
    }
    int i = low;
    int j = high;
    int index=k[i];
    while (i<j){
        while (i<j&&k[j]>=index)
            j--;
        if(i<j){
            k[i++] = k[j];
        }
        while (i<j && k[i]<index)
            i++;
        if(i<j){
            k[j--]= k[i];
        }
    }
    k[i] = index;
    sort(k,low,i-1);
    sort(k,i+1,high);
    }




    public static void main(String[] args){

        int[] a =new int[]{4,9,12,1,7,99,88,38,46,5};

        QuickSort(a);
        for (int t =0;t<a.length;t++){
            System.out.println(a[t]);
        }


}


}

24 Java进程间通信的方式，socket或者共享内存，命名管道等

1. Vector & ArrayList
1） Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。
2）当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。

2. Hashtable & HashMap
Hashtable和HashMap它们的性能方面的比较类似 Vector和ArrayList，比如Hashtable的方法是同步的,而HashMap的不是。

3. ArrayList & LinkedList

ArrayList的内部实现是基于内部数组Object[],所以从概念上讲,它更象数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更象一个链表结构，所以，它们在性能上有很大的差别：
从上面的分析可知,在ArrayList的前面或中间插入数据时,你必须将其后的所有数据相应的后移,这样必然要花费较多时间，所以,当你的操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；而访问链表中的某个元素时,就必须从链表的一端开始沿着连接方向一个一个元素地去查找,直到找到所需的元素为止，所以,当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了

24.实现一个数组的倒置关键点 1. 泛型（用泛型写，调用时候可以随意调用，还可以用Object 类型写，调用的时候需要强转） 2. 临时变量

public class ArrayRE {
    public static  <T> T[] arrayRE(T[] a){
        for(int i=0;a.length>0&&i<(a.length)/2;i++){
            T temp = a[i];
            a[i] = a[a.length-1-i];
            a[a.length-1-i] =  temp;
        }
        return a;
        }
    public static void main(String[] args) {
        Integer[] n={1,2,5,9,6,3,3,1,2};
        String k[]={"3","4","8"};
        Integer[] it = arrayRE(n);
        String[] ss = arrayRE(k);
        for (int i = 0; ss.length>0&&i <ss.length ; i++) {
            System.out.println(k[i]);
        }
    }
}

25. javabean 只要含有set 或者get方法的类就叫 javabean

javaBean在MVC设计模型中是model，又称模型层，在一般的程序中，我们称它为数据层，就是用来设置数据的属性和一些行为，然后我会提供获取属性和设置属性的get/set方法

26 找出一个字符串中所有的数字

public class FindAllNum {
    public static void main(String[] args) {
        String ss = "df12df1246df";
        String s ="";
        Pattern p =Pattern.compile("\\d+");
        Matcher m = p.matcher(ss);
        while (m.find()){
            s=s+m.group();
        }
            System.out.println(s);
    }
}

Python

python 2 和 3的区别

python 中list 和tupple 字典用法

工作中python都处理那些东西

mysql

1.用两种方式根据部门号从高到低，工资从低到高列出每个员工的信息
1.1创建employee表
create table employee(id int primary key auto_increment,name varchar(20),salary double ,deptid int);

1.2插入数据
insert into employee(name,salary,deptid) values("tom1",92,1),("liu",89,1),("feng",70,1),("lengleng",80,1);

1.3 排序
1.4 按照工资从高到底排序
select * from employee order by salary desc;
1.5 根据部门号从高到低，工资从低到高列出每个员工的信息
select * from employee order by deptid desc,salary;

2.列出各个部门中工资高于本部门的平均工资的员工数和部门号，并按部门号排序

select avg(salary) from employee group by deptid;
select employee921.id,employee921.name,employee921.salary,employee921.deptid tid from employee921 where salary > (select avg(salary) from employee921 where deptid = tid);

8.用一条sql语句查询出每门课大于80分的学生姓名
create table score(id int primary key auto_increment,name varchar(20),subject varchar(20),score int);
insert into score values
(1,'张三','语文',81),
(2,'张三','数学',75),
(3,'李四','语文',76),
(4,'李四','数学',90),
(5,'王五','语文',81),
(6,'五','数学',100),
(7,'五 ','英语',90);

select distinct name from score where name not in(select name from score where score <80);

9.取出各科成绩最高的记录