JAVA，

JAVA，

1.找出一组数中最大的数

  import java.util.Scanner;
  public class MaxNum {
public static void main(String[] args) {
int [] arr={23,45,2,4,-1};
int max=arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i]>max){
max=arr[i];
}
      }
System.out.println("这组数中最大的数为："+max);
  }
  }
2.找出数组中不重复的数


3.写代码，单例模式
  //饿汉式
  public class Singleton {
//1.先私有化构造器
private Singleton(){

}
//2.创建一个类的实例,将其设置为静态
private static Singleton instance =new Singleton();
//3.提供公共的方法调用
public static Singleton getInstance(){
return instance;
}
}


  //懒汉式
  public class Singleton {
private Singleton(){

}
private static Singleton instance=null;
public static Singleton getInstance(){
if(instance == null){
instance=new Singleton();
}
   return instance;
}
}

4.数组和链表的区别
    答：数组在通过索引进行查询数据时效率比较高，而对于数据插入和删除操作，则效率比较低。如果在第一个位置插入元素，则 后面的所有元素都需要依次向后移动，而删除第一个数据，其余所有的数据都需要依次向前移动。
    因此，推出了链表的结构。链表在插入、删除数据时，不会影响其他数据的移动。链表是由一系列的节点组成的，每个节点都会    有一个指针，所以我们在插入或者删除的时候，需要该表链表next链的指向地址即可，每个节点不需要内存进行连续存储，这样 会减小删除和插入的线性开销。
   数组与链表的主要区别如下：
  （1）数组静态分配内存，链表动态分配内存。
  （2）数组在内存中连续，链表不连续。
  （3）数组元素在栈区，链表元素在堆区。
  （4）数组利用下标定位，时间复杂度为O（1），链表定位元素时间复杂度为O（n）。
  （5）数组插入或删除元素的时间复杂度为O（n）,链表的时间复杂度为O（1）。

5.hash的用处，怎么解决hash冲突？


6.一个数的个位十位百位相加，判断结果的个位是不是3？
public class Judge {
public static void main(String[] args) {
System.out.println("请输入一个三位数：");
Scanner s=new Scanner(System.in);
int num=s.nextInt(); 

if(num>=100 && num<999){
//获取num的百位
int baiwei=num/100;

System.out.println(baiwei);

//获取num的十位
int shiwei=num%100/10;

System.out.println(shiwei);

//获取num的个位
int gewei=num%100%10;
System.out.println(gewei);

int sum=baiwei+shiwei+gewei;
System.out.println("结果为："+sum);

int gewei1=sum%10;
if(gewei1 == 3){
System.out.println("结果个位为3");
}else{
System.out.println("结果个位不为3");
}
  }
      }
}
7.JAVA的回收机制
    JAVA的垃圾回收机制是java虚拟机提供的能力，用于在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间。垃圾回收的是无任何引用的对象占据的内存空间而不是对象本身。当没有对象引用指向原来分配给某个对象的内存时，该内存便成为垃圾。JVM的一个系统级线程会自动释放内存块。垃圾回收意味着程序不再需要的对象是"无用信息"，这些信息将被丢弃。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被新的对象使用。除了释放无用的对象，垃圾回收也可以清除内存记录碎片。
     优点：
     垃圾回收能自动释放内存空间，减轻编程的负担。这使得JAVA虚拟机具有一些优点。首先，它能使编程效率提高。在没有垃圾回收机制的时候可能要花很多时间来解决一个难懂的存储器问题。在用java语言编程的时候，垃圾回收机制可大大缩短时间。其次是它保证程序的完整性，垃圾回收是java安全性策略的一个部分。

     缺点：

    垃圾回收一个潜在缺点是它的开销影响程序性能。java虚拟机必须追踪运行程序中有用的对象，而且最终释放没用的对象。这一过程需要花费处理器的时间。其次垃圾回收算法的不完备性，最先采用的某些垃圾回收算法不能保证100%收集到所有的废弃内存。

8.JAVA的内存泄露
    内存泄漏是指无用对象（不再使用的对象）持续占有内存或无用对象的内存的不到及时释放，从而造成空间的浪费称为内存泄漏。

9.重载与重写的区别
    重载：“两同一不同”同一个类、同一个方法名；不同的参数列表。
       注：方法的重载与返回值无关。
           构造器是可以重载的。
    重写：（前提：在继承的基础上，子类在获取了父类的结构后，可以对父类中同名的方法进行重构）
       注：方法的返回值 方法名 参数列表形同
           权限修饰符不小于父类的同名方法
           子类的异常对象不大于父类
           两个方法要同为static或同为非static

10.写代码（A TO l）以及此代码的测试用例

11.1G数据怎么排列 

12.写代码（全排列）

13.（int和Integer的区别）
    1.int是java的基本数据类型，Integer是int提供的封装类。
    2. int的默认值是0，Integer的默认值是null。
    3.生命integer的变量需要实例化，声明Integer的变量不需要实例化。
    4.int是基本数据类型，直接存储数值，Integer是对象，用一个引用指向这个对象。


14..main函数执行之前都发生了什么

15.JAVA的多态是怎么体现的?
    多态可以理解成一个事物的多种表现形态。
    多态的表现：1）方法的重载与重写
            2）子类对象的多态性

    多态的使用前提：

     1）要有类的继承

   2）要有子类对父类方法的重写
  
16.堆和栈的区别
    Java把内存划分为两种：一中的栈内存，一种是堆内存。

    在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配的。当在一段代码块定义一个变量时，Java就在栈中为这个变量分配空间，当超过变量的作用域后，java就会自动释放为该变量分配的内存空间，该内存空间可以立即被另作他用。

    堆用来存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机的自动垃圾回收器来管理。

17.写代码，链表反转和冒泡，快排的复杂度分析
   public class 冒泡排序 {
public static void main(String[] args) {
int []arr=new int[]{23,-9,0,45,24,8};
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.println("冒泡排序后遍历数组：");
for(int i1=0;i1<arr.length;i1++){
System.out.print(arr[i1]+"\t");
}
}

}

18.99乘法表
    public class _99 {
 public static void main(String[] args) {
               for(int i=1;i<=9;i++){
  for(int j=1;j<=i;j++){
System.out.print(i+"*"+j+"="+i*j+"  ");
     }
System.out.println();
}
  }
    }

19.写代码：找出一个字符串中字符连续相同的最长子串，如aabbccc，结果就是ccc
import java.util.ArrayList;

public class TheLongString {
public static void main(String[] args) {
Charcount1("aadddrrrr");
}

//方法一
public static void Charcount(String string){
if(string == null){
return;
}
//定义一个数组count,长度为字符串的长度，存放字符串的各个字符出现的次数。
int []count=new int[string.length()];

for(int i=0;i<count.length;i++){
//将字符串中索引字符存在临时变量mid中
char mid=string.charAt(i);

for(int j=0;j<count.length;j++){
if(mid == string.charAt(j))
count[j]++;
}
}
//得到次数最多的字符
int index =0;
int max=count[0];
for(int i=0;i<count.length;i++){
if(max <count[i]){
max=count[i];
index=i;
}
}
System.out.println();
System.out.println("字符："+string.charAt(index));
System.out.println("次数:"+count[index]);
 }

//方法二
public static void Charcount1(String string){
//创建ArrayList，保存字符串中出现的字符
ArrayList list=new ArrayList(string.length());
for(int i=0;i<string.length();i++){
//只要表中不包含，把它添加到表中。
if(!list.contains(string.charAt(i))){
list.add(string.charAt(i));
}
}
int [] count=new int[list.size()];

//这里外循环就不用遍历整个字符串，仅仅按照list表中所保存的字符进行遍历
for(int i=0;i<list.size();i++){
char mid=(char)list.get(i);
for(int j=0;j<string.length();j++){
if(mid == string.charAt(j)){
count[i]++;
}
}
}
int index=0;
int max=count[0];
for(int i=0;i<count.length;i++){
if(max<count[i]){
max=count[i];
index=i;
}
}
System.out.println("字符串中出现的字符:");
for(int k=0;k<list.size();k++){
System.out.println(list.get(k));
}
System.out.println();
System.out.println("字符："+list.get(index)+"出现次数最多！");
System.out.println("出现次数为:"+count[index]);
}
}

20.java中集合类有哪些，区别
   集合（Collection接口 && Map接口）
     -----Collection接口
-----List(动态数组)：存储有序的、可重复的元素。
                   ----ArrayList（主要实现类）
  ----LinkList（对于频繁的插入、删除操作）
  ----Vector（古老的实现类）
-----Set（像高中的集合）：存储无序的、不可重复的元素。
                   ----HashSet
                   ----LinkedhashSet
                   ----TreeSet
     -----Map接口（具有映射关系‘key-value’的集合：存储键值对的集合）
                ----HashMap（类似于高中的函数y=f(x)）：使用hash-table实现，无序。
                ----linkedHashMap：保持着插入顺序。
                ----HashTable:与HashMap实现方式一样，但是Hashtable是同步的。
                ----TreeMap：基于红黑书数据结构实现，按Key排列。
21.ConcurrentHashMap，HashTable，HashMap三者区别


22.手写代码：给定一个字符串，将字符串中的字符转换成int型，注意非法输
23.对手写代码设计测试用例

24.String , StringBuffer和StringBuilder的区别

    String类具有不可变性。程序修改一个字符串时还会额外创建一个对象。当频繁操作字符串时，就会额外产生很多临时变量。

    使用StringBuffer、StringBuilder就可以避免这个问题。
    至于StringBuffer、StringBuilder，他们基本相似，不同之处是StringBuilder是线程安全的，而StringBuffer没有实现线程安全功能，所以性能略高。
    因此，创建一个内容可变的字符串时，首先应该考虑StringBuilder类。
  
25.手写代码，实现字符串中大小写字母的转换
import java.util.Scanner;
public class UpperTo {
  public static void main(String[] args) {
     System.out.println("请输入一个字符串:");
Scanner s=new Scanner(System.in);
String str=s.next();
System.out.println("把字符串中的字符全部转换为小写:"+str.toLowerCase());
System.out.println("把字符串中的字符全部转换为大写:"+str.toUpperCase());
    }
}
26.多线程都用过什么类
  多线程实现的两种方式：
   ①集成Thread类：
   class MyThread extends Thread{


      @Override
      public void run(){
...
    }
  }
   MyThread mt=new MyThread();
   mt.start();


   ②实现Runnerable接口：
    class MyThread implements Runnable{
        @Override
       public  void run(){
  ...    
    }
  }
   MyThread mt=new MyThread();
   Thread td=new Thread(mt);
   td.start();
27.new一个字符串之后，该字符串的值存放在哪？
    new出来的东西放在堆里，字符串的值存放在常量池里。

28.容器类之间的区别set、List、treeset
  
29.泛型的作用
     泛型的主要目标是实现java的类型安全。泛型可以使编译器知道一个对象的限定类型是什么，这样编译器就可以在一个高的程度上验证这个类型。
     消除了强制类型转换，使得代码的可读性好，减少了很多出错的机会。
     使用泛型可以在编译时检查类型安全，并且所有的强制类型转换都是自动和隐式的，提高代码的重用率。
30.求数组最大和第二大的值。
  思路：先排序，然后输出数组的最大和第二大。
  public class SecondMaxNum {
public static void main(String[] args) {
int []arr=new int[]{23,-9,0,45,24,8};
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.println("冒泡排序后遍历数组：");
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.println();
System.out.println("最大的数为:"+arr[arr.length-1]);
System.out.println("第二大的数为:"+arr[arr.length-2]);
}
}
31.你有20元钱，每瓶汽水1元钱，两个空瓶子可以换一瓶饮料，写程序判断可以最多买多少瓶。能不能再多。


32.写反转字符串， 写类的多态
 反转字符串： 
    //方法一
public void Reverse1(String original){
char []c=original.toCharArray();
char[] c1=new char[c.length];
for(int i=0;i<c.length;i++){
c1[i]=c[c.length-1-i];
}
System.out.println(String.valueOf(c1));
}
   //方法二
public void Reverse2(String original){
char []c=original.toCharArray();
for(int i=0;i<c.length/2;i++){
char temp=c[i];
c[i]=c[c.length-1-i];
c[c.length-1-i]=temp;
}
System.out.println(String.valueOf(c));
}


 类的多态：
  类Animal:
    public class Animal {
 public void eat(){
System.out.println("动物吃食物！");
}
    }


  类Dog：
public class Dog extends Animal{
 public void eat(){
System.out.println("狗吃骨头！");
}
    }


  类Cat:
  public class Cat extends Animal{

   }


  测试类：
public class Initail {
 public static void main(String[] args) {
  Animal a=new Animal();
a.eat();
Animal a1=new Dog();
   a1.eat();
   Animal a2=new Cat();
   a2.eat();
}
    }