常见小测试题答案

黄玉昆 · 黄玉昆

20、String s1 = newString("ABC");和String s2 = "ABC";中，先写第一句和后写第一句的区别和联系？

对于上面的代码，有一点要说的：就是无论String s2 = new String("abc")在s1前面写还是后面写，s2都会检查StringPool中是否有"abc"，

若有，就直接在堆内存中创建一个对象；若没有，则要先在StringPool中创建"abc"后，再在堆内存中创建一个对象。这和20题一样的。

但是对于这道题，s1在前，创建两个对象，s1在后，这创建一个对象，因为s2已经在常量池中创建了一个“abc”的字符串对象，则s1就不会在创建了，直接在堆内存中new一个对象。

黄玉昆 · 黄玉昆

21、同步函数是静态的和是非静态的这两者所用的锁有何区别和联系？

1、非静态同步函数中的锁---> this

函数需被对象调用，那么函数都有一个所属的对象引用，就是this，因此同步函数使用的锁为this。

2、静态同步函数中的锁：

如果同步函数被静态修饰后，经验证，使用的锁不是this了，因为静态方法中不可定义this，所以，这个锁不再是this了。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象：类名.class；该对象的类型是Class。

所以静态的同步方法使用的锁是该方法所在类的字节码文件对象，即类名.class。

黄玉昆 · 黄玉昆

22、在使用String类的split()方法是，下面这样写会成功分割为元素吗？如果成功，结果是什么？不成功的话，只使用split()方法，如何成功分割？ Strings = "A.B.C.D.E.java"; s.split(".");

这样截取是不会成功的，会报角标越界的异常，因为无法引号中的点不会被作为截取的标志，如果想让点成为被截取的标志，需要这样操作：s.split("\\.");就可以了。点是特殊字符，需要用\\来转义成普通字符

黄玉昆 · 黄玉昆

23、List集合的特有迭代器是什么？

特有的迭代器是listIterator。

public static void methodListIterator()
{
//演示列表迭代器：
ArrayList list = new ArrayList();
//1.添加元素--->add(Object obj),多态
list.add("java01");
list.add("java02");
list.add("java03");
list.add("java04");
//打印原集合
sop("原集合:" + list);
sop("------------------");
//在迭代过程中，准备添加或删除元素
for (ListIterator it = list.listIterator();it.hasNext(); )
{
Object obj = it.next();
if (obj.equals("java01"))
it.remove();
else if(obj.equals("java02"))
it.add("增加java200");
else if(obj.equals("java03"))
it.set("修改为java300");
sop("obj:" + obj);
}
sop("list :" + list);
}

复制代码

黄玉昆 · 黄玉昆

24、集合中的两种排序方式？

排序有两个要素：元素和集合

1）第一种排序方式：自然排序：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法，这种方式也称为元素的自然排序或默认排序方式。

/*
第一种排序方式：自然排序，实现Comparable接口，重写compareTo方法
需求：
向TreeSet集合中存储自定义对象学生
按照学生的年龄进行排序
*/
import java.util.*;
//此接口强制让Student实现比较性
class Student implements Comparable
{
//定义Student私有属性
private String name;
private int age;
//构造Student函数，初始化
Student(String name,int age)
{
this.name = name;
this.age = age;
}
//公共访问方法，访问私有属性
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//复写Comparator中的compare方法，自定义比较器
public int compareTo(Object obj)
{
//判断是否属于Student类型，否则抛异常
if (!(obj instanceof Student))
throw new RuntimeException("NotSuchTypeException");
//将Object类对象强转为Student类
Student s = (Student)obj;
//System.out.println(this.age + "--compare-" + s.age);//测试用，查看比较情况
//按年龄大小比较，相同则比较姓名大小，不同返回两年龄之差
if (this.age == s.age)
{
return this.name.compareTo(s.name);
}
else if (this.age <s.age)
return this.age-s.age;
return this.age-s.age;
}
/*
//如果按照存入顺序输出
public int compareTo()
{
return 1;//改为-1则按倒叙输出
}
*/
}
//测试
class TreeSetTest
{
public static void main(String[] args)
{
//创建集合，并添加元素
TreeSet ts = new TreeSet();
ts.add(new Student("li01",25));
ts.add(new Student("li02",20));
ts.add(new Student("li01",22));
ts.add(new Student("li05",24));
ts.add(new Student("li08",40));
//打印集合中元素
printE(ts);
System.out.println("Hello World!");
}
//定义打印集合中元素的功能
public static void printE(TreeSet ts)
{
//迭代器方法获取
Iterator it = ts.iterator();
while (it.hasNext())
{
//将返回的元素（Object类）强转为Student类
Student s = (Student)it.next();
System.out.println(s.getName() + "---" + s.getAge());
}
}
}

复制代码

2）第二种排序方式：比较器

当元素自身不具备比较性是，或者具备比较性，却不是所需要的，这时就需要让集合自身具备比较性。在集合初始化时就有了比较方式（即参阅构造函数）。

当两种排序方式都存在时，以比较器为主。

如何构造比较器：定义一个类，实现Comparator接口，覆盖compare方法。

import java.util.*;
//此接口强制让Student实现比较性
class Student implements Comparable
{
//定义Student私有属性
private String name;
private int age;
//构造Student函数，初始化
Student(String name,int age)
{
this.name = name;
this.age = age;
}
//公共访问方法，访问私有属性
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//复写Comparator中的compare方法，自定义比较器
public int compareTo(Object obj)
{
//判断是否属于Student类型，否则抛异常
if (!(obj instanceof Student))
throw new RuntimeException("NotSuchTypeException");
//按年龄大小比较，相同则比较姓名大小，不同返回两年龄之差
Student s = (Student)obj;
if (this.age > s.age)
return this.age-s.age;
else if (this.age == s.age)
{
return this.name.compareTo(s.name);
}
return this.age-s.age;
}
}
//定义比较器，实现Comparator接口
class MyCompare implements Comparator
{
//重写Comparator中的compare方法，按姓名顺序排序
public int compare(Object o1,Object o2)
{
//判断给定对象是否为Student类，否则抛异常
if (!((o1 instanceof Student) && (o2 instanceof Student)))
throw new RuntimeException("NotSuchTypeException");
//将给定对象强转为Student类
Student s1 = (Student)o1;
Student s2 = (Student)o2;
//比较名字，返回数值，相同则比较年龄
int n = s1.getName().compareTo(s2.getName());
if (n == 0)
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
return n;
}
}
//测试
class TreeSetComDemo
{
public static void main(String[] args)
{
//TreeSet ts = new TreeSet();
//创建集合，加入接口类参数，并添加元素
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("li01",25));
ts.add(new Student("li02",20));
ts.add(new Student("li01",22));
ts.add(new Student("li05",24));
ts.add(new Student("li08",40));
//打印集合中元素
printE(ts);
}
//定义打印集合中元素的功能
public static void printE(TreeSet ts)
{
//迭代器方法获取
Iterator it = ts.iterator();
while (it.hasNext())
{
//将返回的元素（Object类）强转为Student类
Student s = (Student)it.next();
System.out.println(s.getName() + "---" + s.getAge());
}
}
}

复制代码

黄玉昆 · 黄玉昆

25、集合中的两种取出方式？

keySet()和entrySet()方法

1、keySet()方法获取元素

原理：将Map集合中的所有键存入到Set集合中，因为Set集合具备迭代器，所以可以用迭代方式取出所有的键，再根据get方法获取每一个键对应的值。简单说就是：Map集合---->Set集合 ---->迭代器取出

import java.util.*;
class KeySetDemo
{
public static void main(String[] args)
{
//创建Map集合，并添加元素
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(2,"zhangsan");
map.put(6,"lisi");
map.put(3,"wangwu");
map.put(4,"heihei");
map.put(5,"xixi");
//获取map集合中的所有键的Set集合
Set<Integer> keySet = map.keySet();
//有了Set集合就可以获取其迭代器，取值
Iterator<Integer> it = keySet.iterator();
while (it.hasNext())
{
Integer i = it.next();
String s = map.get(i);
System.out.println(i + " = " + s);
}
}
}

复制代码

2、entrySet()方法获取元素：

原理：将Map集合中的映射关系存入到了Set集合中，而这个映射关系的数据类型是Map.Entry，在通过迭代器将映射关系存入到Map.Entry集合中，并通过其中的getKey()和getValue()放取出键值。

import java.util.*;
class EntrySetDemo
{
public static void main(String[] args)
{
//创建集合，存入元素
Map<String,String> map = new HashMap<String,String>();
map.put("01","lisi1");
map.put("02","lisi2");
map.put("03","lisi3");
map.put("04","lisi4");
//获取map集合中的所有键，存入到Set集合中，
Set<Map.Entry<String,String>> entry = map.entrySet();
//通过迭代器取出map中的键值关系，迭代器接收的泛型参数应和Set接收的一致
Iterator<Map.Entry<String,String>> it = entry.iterator();
while (it.hasNext())
{
//将键值关系取出存入Map.Entry这个映射关系集合接口中
Map.Entry<String,String> me = it.next();
//使用Map.Entry中的方法获取键和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + " : " + value);
}
}
}

复制代码

黄玉昆 · 黄玉昆

26、FileWriter和File创建文件的区别和联系？

File创建文件是先查看文件是否存在，如果存在则返回true，不存在则创建一个新文件

FileWriter创建对象时，不论文件存不存在，都会覆盖，创建新的文件

黄玉昆 · 黄玉昆

本帖最后由黄玉昆于 2013-3-17 20:41 编辑

27、请将你知道的最简单的几种死循环形式写出来

第一种：for(;;)

第二种：while(){}

第三种：do {}while(1);

第四种：public void show(){show();}

黄玉昆 · 黄玉昆

预留楼层

黄玉昆 · 黄玉昆

预留楼层

wangjinyu501 · wangjinyu501

本帖最后由 wangjinyu501 于 2013-3-14 15:58 编辑

java多线程是不是很麻烦啊

熊冠银 · 熊冠银

黄玉昆发表于 2013-3-14 15:43
17、Outer.Inner in = new Outer(new Inner())，请对这句话解释一下这个是在外部其他类中直接建立内部类对 ...

不是应该这样写吗？Outer.Inner in=new Outer().new Inner();
题目上的那句话，我怎么看着都像是new外部类对象，初始化时传入了内部了对象

彭波 · 彭波

很好，这样提高会很快的

符立波 · 符立波

不错......

张豪杰 · 张豪杰

本帖最后由张豪杰于 2013-3-15 10:46 编辑

楼主，第二十五题我有疑惑：
25、集合中的两种取出方式？
问题是问集合中的取出方式，但是你给的答案仅仅只是写出Map的两种取出方式
像List集合中的用迭代器取出，还有高级for取出元素，这应该也是吧？
难道List和Set都不属于集合体系？还是我对问题理解有误？
或者这道题的题目应该指明是“Map集合的两种取出方式”？

黄玉昆 · 黄玉昆

张豪杰发表于 2013-3-15 10:44
楼主，第二十五题我有疑惑：
25、集合中的两种取出方式？
问题是问集合中的取出方式，但是你给的答案仅仅只 ...

你这么说也有道理，说的很准确；我觉得大家应该都理解我说的意思，因为在看视频都知道毕老师讲的这两种方式是说的Map集合，理解就好了。谢谢你

黄诗宾 · 黄诗宾

顶顶顶支持了

黄文伯 · 黄文伯

楼主辛苦了{:soso_e113:}

李道福 · 李道福

黄玉昆发表于 2013-3-14 15:42
6、是否可以从一个static方法内部发出对非 static方法的调用？不可以,如果其中包含对象的method()；不能保 ...

public class A{
public static void main(String[] args){
  A a=new A();
  A.print(a); //这个算不算在静态方法内发出对非静态方法的调用？
}
void show(){
  System.out.println("hello");
}
static void print(A a){
  a.show();
}
}

蔡辉 · 蔡辉

嘿嘿,顶一个

帐号		自动登录	找回密码
密码			加入黑马

常见小测试题答案

评分

评分

评分

评分

浏览过的版块

黑马骑士勋章