- 在byte、short、char做运算时，要先转换成int类型在进行计算。
- 整数相除结果是整数，如果想要小数，则在参与运算的数据必须要有一个浮点类型的参数。
- 一般情况下，大括号与分号是不能共存的。
- 在计算机的底层运算中，采用的是补码的形式。
- +号与字符串类型的数据一起使用，表示连接符。
- 无限循环的两种形式：for（；；）{}、while（ture）{}。
- 方法区中的常量池
关于Integer类型的数据的计算，如果数值在byte类型范围之内时，不会再创建对象，而是调用在常量池中熟知的地址值。 - 注意：
数组:使用的是数组的 .lenght 属性
字符串:使用的是字符串的 .length()方法 - byte常量池（关于Integer）
也就是说byte范围内的值，直接赋值给Integer时，是从常量池中获取的，并没有重新开辟空间 - JDK1.5后的新特性
a： 自动装箱： 也就是把基本类型直接赋值给引用类型。
Integer i=100；
等价于： Integer ii= new Integer (100);
b：自动拆箱： 也就是把引用类型直接拆成基本类型
Integer i = 10; //装箱
int t = i; //拆箱，实际上执行了 int t = i.intValue(); - java中的开发原则
只要是对象，就做不为null的判断操作
如：Arrays类的toString（）方法的底层代码。 - 把字符串中的数字字符排序
需求：
现在有一个字符串“23 98 71 54 60”，请把这个字符串变成如下字符串“23 54 60 71 98”.
思路：
a:把字符串变成字符数组；
b:把字符数组转变成int数组；
c:对转变后的int[]数组排序
d:把排序后的int[]数组转成String. - int和String之间的转换
a： int转换成String
int num=100;
方式1： string s=100+"";
方式2：String s=String.valueOf(num);
方式3：Integer i=new Integer(num); String s=i.toString();
方式4：String s=Integer.toString(num);//静态调用
b： String转int
String s=“123”；
方式1：Integer i=new Integer(s);int number=i.intValue();
方式2：int number=Integer.parseInt(String s);//静态调用 - 字符流和字节流的区别：
字符流处理的是2个字节，可以处理字符，字符串，字符数组；
字节流操作的是一个字节，可以处理字节和字节数组，字符流需要刷新才能使用数据而字节流不需要，说明字符流使用缓冲。 - 多线程有Thread为什么还要Runnnable借口呢？
避免类单继承的局限性
是数据与操作分离
低耦合高内聚 - 关于==做比较的问题
基本类型的比较:比较的是具体的值
引用类型的比较:比较的是对象的地址值 - 实现对象的成员变量数据的比较
compare方法的三步改进代码
A :
public boolean compare(int age1,int age2)
{
return age1 == age2;
}
//在main方法中的调用方式
boolean b1 = s1.compare( s1.getAge() , s2.getAge() );
B:
public boolean compare ( Student s1, Student s2)
{
return s1.age == s2.age;
}
//在main函数中的调用方式
boolean bl = s1.compare( s1 , s2 );
C:
public boolean compare ( Student s)
{
return this.age == s.age;
}
//在main函数中的调用方式
boolean bl = s1.compare( s2 );
-
Object类的equals方法_理解
- 在比较两个对象时为什么要重写 equals 方法?
因为该方法底层默认比较的还是地址值,而同一个类中的不同对象,地址值肯定不同
所以Object类中的equals 方法没有意义,所以我们需要重写它,比较的是对象当中的属性.
Student s=(Student)obj;
重写equals一般就是为了比较某个类的多个对象的所有成员变量值是否相同；
如果成员变量是基本类型，就用==比较；
如果成员变量是引用类型，就用该变量对应的引用类型的equals（）方法；
return this.age==s.age&&this.name.equals(s.name);
- 在比较两个对象时为什么要重写 equals 方法?
-
String类的equals()方法详细解析
理解：其实字符串在底层是一个字符数组的形式存在的
String类的equals的方法的思路：
1、判断是否为同一个对象；
2、判断对象是否属于String类；
3、判断字符数组的长度是否相同；
4、比较字符串中的值是否对应相同；
示例：
String类的equals方法：
public boolean equals(Object anObject) {
if (this == anObject) {//判断地址值是否相等
return true;
}
if (anObject instanceof String) {//判断anObject是否是String类的对象
String anotherString = (String) anObject;//将anObject类向下转型为String
//value在String中的定义
//private final char[] value
//字符串 -- 底层字符数组。
int n = value.length; //s1长度5
//value.length -- this.value.length -- s1.toCharArray().length
//把s1字符串转变成了一个字符数组
//char[] value = s1.toCharArray();
//char[] value = {'h','e','l','l','o'};
//把字符串s2也转变成了字符数组，然后获取长度，和n进行比较
//如果长度相等就进去。
//char[] value2 = {'h','e','l','l','o'};
if (n == anotherString.value.length) {
//如果长度相同，就进来继续比较。
char v1[] = value; //{'h','e','l','l','o'};
char v2[] = anotherString.value; //{'h','e','l','l','o'};
int i = 0;
//n=5;是字符串的长度
while (n-- != 0) {
//n=4,
//依次按索引位置比较每一个字符是否相同，如果不同，就返回false.
//如果每个索引对应的值都相同，那么整个字符串是相同的。
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
面试题
byte b1 = 3;
byte b2 = 4;
byte b3 = b1 + b2;
byte b4 = 3 + 4;
a = a + 20;
a += 20;
结果是等价的，理解不是等价的。
因为+=这种运算符，内含了强制类型转换功能。
比如：
short s = 2;
s+=3;
等价于
s = (short)
3.2*8最有效的方式
4.10和20 交换的方式
5.在Java中，下列（B）语句不能通过编译。D
A. String s = "join"+ "was"+ "here";
B. String s = "join"+3;
C. int a = 3+5;
D. float f = 5+5.5;
6、Scanner的注意问题
1、Scanner键盘录入的时候需要注意的问题及解决方法
如何会出现问题：先输入一个int类型再输入一个String类型会出问题，会默认把换行字符当作一个字符串给string类型。
解决方法①：再去创建一个Scanner对象(方法1常用)
解决方法②：数据都用String类型接收,再把字符串转换为int类型。
7、String常见面试题
1、如何理解字符串一旦初始化就不可以被改变。
String s = "hello";
s += "world";
System.out.println(s);
不可以被改变说的是常量池中的值,并不是引用s(s是可以重新被赋值的)
2、
String s1 = new String("abc");
String s2 = "abc"；
s1、s2有区别吗？
第一种方式：第一种方式在内存中存在两个"abc"字符串,一个是在常量池中,一个是在堆内存当中.
第二种方式：在内存中只存在一个"abc"在常量池中.
String
1.字符串方法调用问题
public static void main(String[] args)
{
String s = "abc";
change(s);
System.out.println(s);//结果：abc
}
public static void change(String s)
{
s += "hello";
}
//发现：变量被change方法调用会不会改变取决于?取决于你这个变量指向的是哪个位置？
如果指向的是方法区中的常量池这个位置的话，不会改变
如果指向的是堆内存中的数据，会改变
基本类型：形式参数的改变不会影响实际参数。
引用类型：形式参数的改变会直接影响实际参数，但字符串是一个特殊的引用类型。
2.字符串拼接问题
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
String s3 = "ab";
System.out.println(s3 == s1 + s2);//false
System.out.println(s3 == "a" + "b");//true
}
Interger
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//false
System.out.println(i1.equals(i2));true
System.out.println("--------");
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//false
System.out.println(i3.equals(i4));//true
Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);//false
System.out.println(i5.equals(i6));//true
System.out.println("--------");
Integer i7 = 127;
Integer i8 = 127;
System.out.println(i7 == i8);//true
System.out.println(i7.equals(i8)); //true
常量相加会直接累加，然后在常量池里面找有没有，如果有就直接使用常量池中的值，而变量相加会重新开辟空间。
- 面试题：sleep和wait()的区别?
- wait():是Object类的方法，可以不用传递参数。释放锁对象。
- sleep():是Thread类的静态方法，需要传递参数。不释放锁对象。
8、Collection和Collections的区别？
A：Collection是Collection体系的顶层接口,里面定义了这个体系中的共性方法.
B：Collections是针对Collection集合操作的工具类 里面一定了一些对集合操作的方法
比如 排序,查找,反转,最值,置换
9、异常面试题：
1、请问final，finally，finalize的区别。
final
是个关键字
它修饰的类不能被继承
它修饰的方法不能不重写
它修饰的变量就变成了常量
finally
是一个关键字,是异常处理的一部分
一般用在捕获异常时,它里面的代码永远会被执行
(特殊情况在执行到finall之前就退出了虚拟机)
finalize()
是Object类中垃圾回收的方法
2 假如在catch里面有return语句，请问finally里面的代码还会执行吗?如果执行，是在return前，还是return后?
会执行。在return前执行。
准确答案:在return之间执行。
网友评论