今天早上主要练习了一些题巩固了一些之前的知识
例一：
package com.yan1;
/*
* 定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边。
* （可以创建其他数组，不必须在原数组中改变）
*/
public class Test1 {
public static void main(String[] args) {
int[] arr = new int[] { 1, 2, 3, 5, 6, 7, 9, 10, 13 };
int[] brr=new int[arr.length];
int k1=0;
int k2=arr.length-1;
for(int tmp:arr) {
if(tmp%2!=0) {
brr[k1++]=tmp;
}
if(tmp%2==0) {
brr[k2--]=tmp;
}
}
System.out.println("index1:"+k1+"\tindex2:"+k2);
for(int tmp:brr)
System.out.print(tmp+"\t");
}
}
例二：
package com.yan1;
import java.util.Scanner;
/*
* 校招题目：
* 键盘读取一组数据，按照要求进行数据的重排列，使相邻数据之和为奇数的个数为指定值
*
* 奇+奇=偶 偶+偶=偶 只有奇+偶=奇
*
* 9
* 1 2 3 5 6 7 9 10 13
* 2
*/
public class Test2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 第一个数据是数组长度
int k1 = sc.nextInt();
int[] arr = new int[k1];
for (int i = 0; i < k1; i++)
arr[i] = sc.nextInt();
// 最后一个整数是要求排列后的奇数和的个数
int k2 = sc.nextInt();
sc.close();
// 解决问题：首先按照奇偶区分的方式存储数据
int[] brr = new int[arr.length];
int index1 = 0, index2 = brr.length - 1;
for (int tmp : arr) {
if (tmp % 2 != 0) {
brr[index1++] = tmp;
}
if (tmp % 2 == 0) {
brr[index2--] = tmp;
}
}
for (int tmp : brr)
System.out.print(tmp + "\t");
// 控制次数
if ((k2 - 1) % 2 != 0) {
// 获取一个奇数将其插入到数组的末尾,使其参数一个相邻数之和为奇数
int kk = brr[0];
for (int i = 1; i < brr.length; i++) {
brr[i - 1] = brr[i];
}
brr[brr.length - 1] = kk;
k2--;
index2--;
}
int num = (k2 - 1) / 2;
// 获取一个奇数插入到偶数中
// 3 5 7 9 13 10 6 2 1
for (int i = 0; i < num; i++) {
int qiShu = brr[0];
int pos = index2 + 2;
for (int n = 1; n < pos; n++) {
brr[n - 1] = brr[n];
}
brr[pos - 1] = qiShu;
}
System.out.println();
for (int tmp : brr)
System.out.print(tmp + "\t");
System.out.println(index2++);
}
}
例三：
package com.yan1;
public class Test3 {
public static void main(String[] args) {
int[] arr = new int[] { 1, 2, 3, 5, 6, 7, 9, 10, 13 };
int num = 6;
int[] brr = new int[arr.length];
int k1 = 0;
int k2 = arr.length - 1;
for (int tmp : arr) {
if (tmp % 2 != 0) {
brr[k1++] = tmp;
}
if (tmp % 2 == 0) {
brr[k2--] = tmp;
}
}
System.out.println();
for (int temp : brr)
System.out.print(temp + "\t");
if ((num - 1) % 2 != 0) {
int tmp = brr[0];
for (int i = 1; i < brr.length; i++) {
brr[i - 1] = brr[i];
}
brr[brr.length - 1] = tmp;
k2--;
}
k2++;
int nn = (num - 1) / 2;
for (int k = 0; k < nn; k++) {
int tmp = brr[0];
for (int i = 1; i <= k2; i++) {
brr[i - 1] = brr[i];
}
brr[k2] = tmp;
k2++;
}
System.out.println();
for (int temp : brr)
System.out.print(temp + "\t");
}
}
例四：
package com.yan1;
//现有一个小数数组{12.9,53.54,75.0,99.1,3.14}。请编写代码，找出数组中的最小值并打印
public class Test4 {
public static void main(String[] args) {
double[] arr = { 12.9, 53.54, 75.0, 99.1, 3.14 };
double min = Double.MAX_VALUE;
for(int i=0;i<arr.length;i++) {
if(arr[i]<min)
min=arr[i];
}
System.out.println(min);
}
}
例五：随机生成20个整数[50,200)，使用冒泡排序，然后打印输出
方法一：
package com.yan1;
import java.util.Random;
public class Test6 {
public static void main(String[] args) {
int[] arr = new int[20];
Random r = new Random();
for (int i = 0; i < 20; i++)
arr[i] = r.nextInt(150) + 50; // [50,200)
for (int i = 1; i < arr.length; i++) {
for (int k = 0; k < arr.length - i; k++) {
if (arr[k] < arr[k + 1]) {
int tmp = arr[k];
arr[k] = arr[k + 1];
arr[k + 1] = tmp;
}
}
}
int cc = 0;
for (int tmp : arr) {
++cc;
// 满6个换行
System.out.print(tmp + "\t");
if (cc % 6 == 0)
System.out.println();
}
}
}
方法二：
package com.yan1;
import java.util.Random;
public class Test5 {
public static void main(String[] args) {
int kk = (int) (Math.random() * 100);
// 针对生成随机数，不一定是数值型。Java提供了一个工具类java.util.Random，使用这个工具类可以生成所需要类型的随机数
Random r = new Random();// 构建随机对象
int k1=r.nextInt();
int k2=r.nextInt(200);//参数用于指定随机整数的范围,参数200表示[0,200)之间的随机数
System.out.println(k1+"--"+k2);
}
}
例六：
package com.yan2;
import java.util.Random;
//遍历数组查找指定的值target
public class Test1 {
public static void main(String[] args) {
int[] arr = new int[20];
Random r = new Random();
for (int i = 0; i < arr.length; i++)
arr[i] = r.nextInt(15);
int target = 13;
int pos = -1;
for (int i = 0; i < arr.length; i++) {
if (target == arr[i]) { // 时间复杂度为O(n)
pos = i;
break;
}
}
if (pos == -1)
System.out.println("数据不存在");
else
System.out.println(target + "位于数组中第" + pos + "位置上");
}
}
例七：
package com.yan2;
import java.util.Random;
//遍历数组查找指定的值target
/*
* 折半查找：前提是数据必须有序
*
*/
public class Test2 {
public static void main(String[] args) {
int[] arr = new int[20];
arr= new int[] {11,22,10,25,45,17,19,22,34,13};
// Random r = new Random();
// for (int i = 0; i < arr.length; i++)
// arr[i] = r.nextInt(15);
int target = -45;
//排序
for(int k=1;k<arr.length;k++) {
for(int i=0;i<arr.length-k;i++) {
if(arr[i]>arr[i+1]) {
int tmp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=tmp;
}
}
}
for(int tmp:arr)
System.out.print(tmp+"\t");
System.out.println();
//开始折半查找---折半的前提是数据有序
int begin=0;
int end=arr.length-1;
int pos=-1;
boolean flag=false;
while(begin<=end) {
pos=(begin+end)/2; //时间复杂度为O(logN)
if(arr[pos]>target) {
end=pos-1;
}else if(arr[pos]<target) {
begin=pos+1;
}else {
flag=true;
break;
}
}
if(flag)
System.out.println(pos);
else
System.out.println(-1);
}
}
例八：倒序排列
方法一：
package com.yan2;
//数组逆序
public class Test3 {
public static void main(String[] args) {
int[] arr= {1,2,3,4,6};
int[] brr=new int[arr.length];
//时间复杂度为O(n),空间复杂度为O(n)
for(int i=arr.length-1,k=0;i>=0;i--)
brr[k++]=arr[i];
for(int tmp:brr)
System.out.print(tmp+"\t");
}
}
方法二：
package com.yan2;
public class Test4 {
public static void main(String[] args) {
int[] arr= {1,2,3,4,6};
/* 5
*
* 0 4
* 1 3
* 2
*
* 时间复杂度O(n),空间复杂度O(1)
*/
for(int i=0;i<arr.length/2;i++) {
int pos=arr.length-i-1;
int tmp=arr[i];
arr[i]=arr[pos];
arr[pos]=tmp;
}
for(int tmp:arr)
System.out.print(tmp+"\t");
}
}
方法三：
package com.yan2;
public class Test5 {
public static void main(String[] args) {
int[] arr= {1,2,3,4,6};
int begin=0;
int end=arr.length-1;
while(begin<end) {
int tmp=arr[begin];
arr[begin]=arr[end];
arr[end]=tmp;
begin++;
end--;
}
for(int tmp:arr)
System.out.print(tmp+"\t");
}
}
例九：
package com.yan4;
import java.util.Random;
import java.util.Scanner;
//猜数字游戏。存取5个随机的1~20之间的不重复的数据
public class Test1 {
public static void main(String[] args) {
int[] arr = new int[5];
Random r = new Random();
for (int i = 0; i < 5; i++) {
int temp = r.nextInt(20) + 1;
if (exists(arr, temp)) {
i--;
} else
arr[i] = temp;
}
for(int tmp:arr)
System.out.print(tmp+"\t");
System.out.println();
Scanner sc = new Scanner(System.in);
while (true) {
int kk = sc.nextInt();
if(exists(arr,kk)) {
System.out.println("猜对了!");
break;
}else {
System.out.println("猜错了!");
}
}
sc.close();
}
public static boolean exists(int[] array, int target) {
boolean res = false;
if(target>20 || target<1)
return res;
for (int i = 0; i < array.length; i++) {
if (array[i] == target) {
res = true;
break;
}
}
return res;
}
}
例十：
package com.yan4;
//有一个整数数组，其中存放着序列1、3、5、7、11、13、15、17、19，请将该序列倒序存放并输出
public class Test3 {
public static void main(String[] args) {
int[] arr= {1,3,5,7,11,13,15,17,19};
int begin=0;
int end=arr.length-1;
while(begin<end) {
int tmp=arr[begin];
arr[begin]=arr[end];
arr[end]=tmp;
begin++;
end--;
}
for(int tmp:arr) {
System.out.print(tmp+"\t");
}
}
}
例11：
package com.yan4;
import java.util.Scanner;
//编写一个程序，提示用户输入学生数量后，再依次输入姓名和成绩[整数]，按照成绩的降序来打印学生的姓名
public class Test4 {
public static void main(String[] args) {
int len=0;
Scanner sc=new Scanner(System.in);
System.out.println("要输入的学生个数:");
len=sc.nextInt();
int[] scs=new int[len];
String[] names=new String[len];
for(int i=0;i<len;i++) {
String name=sc.next();
int score=sc.nextInt();
scs[i]=score;
names[i]=name;
}
sc.close();
//冒泡
for(int i=1;i<scs.length;i++) {
for(int k=0;k<scs.length-i;k++) {
if(scs[k]<scs[k+1]) {
int tmp=scs[k];
scs[k]=scs[k+1];
scs[k+1]=tmp;
String temp=names[k];
names[k]=names[k+1];
names[k+1]=temp;
}
}
}
//输出
for(int temp:scs)
System.out.print(temp+"\t");
System.out.println();
for(String temp:names) {
System.out.print(temp+"\t");
}
}
}
例12：
package com.yan4;
import java.util.Random;
//编写一个程序，随机生成10个整数，并且存储其中互不相同的数，最后将这10个数输出
//编写一个程序，随机生成10个非0整数，并且存储其中互不相同的数，最后将这10个数输出
public class Test5 {
public static void main(String[] args) {
int[] arr = new int[10];//默认值的问题
// for(int tmp:arr)
// System.out.print(tmp+"\t");
int cc = 0;
Random r = new Random();
while (cc < 10) {
int tmp=r.nextInt();
if(!exists(arr, tmp)) {
arr[cc++]=tmp;
}
}
for(int tmp:arr) {
System.out.print(tmp+"\t");
}
}
public static boolean exists(int[] array, int target) {
boolean res = false;
if (target > 20 || target < 1)
return res;
for (int i = 0; i < array.length; i++) {
if (array[i] == target) {
res = true;
break;
}
}
return res;
}
}
例13:
package com.yan4;
import java.util.Random;
//编写一个程序，随机生成10个整数，并且存储其中互不相同的数，最后将这10个数输出
public class Test6 {
public static void main(String[] args) {
int[] arr = new int[10];// 存储实际数据
String source = "";// 用于存在性判断
int cc = 0;
Random r = new Random();
while (cc < 10) {
int temp=r.nextInt(12);
System.out.println(temp);
if(!exists(source, temp)) {
arr[cc++]=temp;
source=source+temp+",";
}
}
System.out.println("---------------------");
for(int temp:arr)
System.out.print(temp+"\t");
}
public static boolean exists(String source, int target) {
return source.indexOf("" + target) >= 0;
}
}
下午在牛客网上看了相关的面试题
int和Integer有什么区别？谈谈Integer的值缓存范围
答
：int是整形数字，是Java的8个原始数据类型（Primitive Types，boolean、byte、short、char、int、
float、double、long）之一。Java 语言虽然号称一切都是对象，但原始数据类型是例外
Integer是int对应的包装类，它有一个int类型的字段存储数据，并且提供了基本操作，比如数学运算、
int和字符串之间转换等。在Java5中，引入了自动装箱和自动拆箱功能boxing/unboxing，Java可以根据
上下文，自动进行转换，极大地简化了相关编程
大部分数据操作都是集中在有限的、较小的数值范围，因而，在Java 5中新增了静态工厂方法 valueOf，
在调用它的时候会利用一个缓存机制，带来了明显的性能改进。按照Javadoc这个值默认缓存是-128到
127之间
**注意：**1、基本类型均具有取值范围，在大数*大数的时候，有可能会出现越界的情况
2、基本类型转换时，使用声明的方式。例：long result= 1234567890 * 24 * 365；结果值一定不会
是你所期望的那个值，因为1234567890 * 24已经超过了int的范围，如果修改为：long result=
1234567890L * 24 * 365；就正常了
3、慎用基本类型处理货币存储。如采用double常会带来差距，常采用BigDecimal、整型（如果要精
确表示分，可将值扩大100倍转化为整型）解决该问题
4、Math.abs(100-b)<1e-6
5、优先使用基本类型。原则上，建议避免无意中的装箱、拆箱行为，尤其是在性能敏感的场合
6、如果有线程安全的计算需要，建议考虑使用类型AtomicInteger、AtomicLong 这样的线程安全
类。部分比较宽的基本数据类型，比如 float、double，甚至不能保证更新操作的原子性，可能出
现程序读取到只更新了一半数据位的数值
请解释Java语言的跨平台特性
答：
Java的跨平台特性也被称为可移植性、平台无关性，或者一次编写处处运行。他的意思就是
如果用Java语言编写一个应用，那么就可以在不同平台上运行，而不需要为不同平台单独运行开发。之所以能实现跨平台的特性。主要得益于Java虚拟机（JVM），JVM解释器在运行Java应用时根据当前平台进行解释，解释成符合当前平台规范的机器码，所以可以实现同样的应用在不同平台上都能运行。
请列举JAVA语言的主要特点
答：
JAVA语言有很多特点，主要包括①跨平台性：一个应用可以不经过修改直接运行到不同的平台上。②面向对象：JAVA语言是一门面向对象的语言，可以使用对象的属性和行为，可以使用面向对象的思想进行分析设计，并实现整个应用。③解释执行JAVA应用时，JVM中的解释器将解释类文件，生成符合当前平台的字节码。④自动回收：JAVA应用中的垃圾回收是自动进行的，JVM中的后台线程将监视内存中数据的使用，当内存中的数据不再被引用时，将被作为垃圾回收，而不需要程序员动手回收。
什么叫引用类型，引用类型和基本数据类型有什么区别
答：
Java语言中除了基本数据类型之外的类型，都称为引用类型。引用类型就是类的类型，所有
的对象都是引用类型，包括数组对象。引用类型必须使用new调用构造方法进行赋值，引用类型的变量拥有自己的属性和方法，可以使用圆点调用自己的属性和方法。基本数据类型直接使用=号进行赋值，且没有自己的属性和方法，往往都在声明属性或方法时使用。
对于String对象，可以使用=赋值，也可以使用new关键字赋值，两种方式有什么区别？
答：
使用“=”赋值不一定每次都创建一个新的字符串，而是从“字符串实例池”中查找字符串。使用
new进行赋值，则每次都创建一个新的字符串。
包装器类型包括哪些类，有什么作用？
答：
包装类器包括Byte、Short、Integer、Long、Float、Double、Character、Boolean等类，
主要用来对byte、short、integer、long、float、double、character、boolean这八种基本数据类型进
行包装，使其称为引用类型。
String类和StringBuffer类有什么区别？
答：
String类是不可变类，即字符串值一旦初始化后就不可能改变。StringBuffer是可变字符串
类，类似String的缓冲区，可以修改字符串的值。
版权声明：本文为m0_58414041原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。