java如何向量化数据

转载

hackernew 2024-09-02 14:05:00

文章标签 java如何向量化数据 java 面试 javascript ViewUI 文章分类 Java 后端开发

1.Java中求数组char ch[]的长度(元素的个数): ch.length；求字符串s的长度：s.length()；

2.arraycopy函数用于拷贝数组，定义如下：

　　static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

　　从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

　　src:要被复制的源数组

　　srcPos:要被复制的数组的起始位置，从0开始算

　　dest:复制到的目标数组

　　destPos:要放入的目标数组的位置，从0开始算

　　length:被复制的源数组的长度

　　NB:注意目标位置的元素将会被替换掉

　　例如:

int a=new int[]{1,2,3,4,5};  
int b=new int[]{6,7,8,9}
System.arraycopy(a,2,b,1,3);
int a=new int[]{1,2,3,4,5};  
int b=new int[]{6,7,8,9}
System.arraycopy(a,2,b,1,3);

　　这句之后，b={6,3,4,5}

byte b1=10+1;//通过
byte b2=2;  byte b3=3;
byte b4=b2+b3;//出错，类型不兼容
byte b5=(byte)(b2+b3);//通过
byte b1=10+1;//通过
byte b2=2;  byte b3=3;
byte b4=b2+b3;//出错，类型不兼容
byte b5=(byte)(b2+b3);//通过

问：b1的右边是加法，b4的右边也是加法，为什么第一句通过，第二句报错？

答：编译器在编译时，会将能够直接计算出来的数据先计算，便于提升效率。因此b1的右边，会被编译器看作11而不是10+1，编译器知道int类型的11转换成byte类型时，没有超过byte类型的表示范围，因此不报错；对于b4，由于b2和b3不是直接量，编译器在编译时不能直接识别b2+b3的值是多少，而在运行时才能够确定，因此编译器不能确定int类型值(b2+b3)在转换成byte类型时是否会超过byte类型的有效表示范围，又因为Java是一种安全的语言，因此编译器会报错，说不能转换成byte类型。而把右边强制转换成byte类型后，编译器的错误就消失了，就像b5一样。因为编译器知道是程序员让编译器这样做的，就算超过byte的表示范围，编译器也会忽略这个问题，因为编译器知道这个问题程序员已经考虑到了。

while(…){
    if(…){
       break;//这个break不是退出if，而是退出while循环
    }
}
while(…){
    if(…){
       break;//这个break不是退出if，而是退出while循环
    }
}

5.分析以下代码出错的原因：

Father.java:

public class Father {
    private String name;
    public Father(String name){
        this.name=name;
    }
}
public class Father {
    private String name;
    public Father(String name){
        this.name=name;
    }
}

Son.java

public class Son extends Father{ }//报错
 public class Son extends Father{ }//报错

　　答：子类虽然什么都没写，但是系统会为子类添加一个默认的构造函数，如果这个构造函数没有this关键字，则第一句会调用父类的无参构造函数。而父类中没有无参构造函数，因此报错。英文的意思是：隐含的super()默认构造函数没有定义，必须定义一个隐含的构造函数。

　　记住：任何一个子类的构造函数，一定会调用父类的构造函数。

char[] c=new char[]{‘A’,’B’,’C’,’D’,’E’};
System.out.println(c);//输出c内的元素：ABCED
System.out.println(“char[] c:”+c);//输出char[] c:[C+地址（hashCode）
char[] c=new char[]{‘A’,’B’,’C’,’D’,’E’};
System.out.println(c);//输出c内的元素：ABCED
System.out.println(“char[] c:”+c);//输出char[] c:[C+地址（hashCode）

　　打印一个boolean的数组时，若参数直接为该数组，则打印结果为 [Z@+地址

　　任何值与字符串想加得到的都是字符串

7. Java中的字符串（String）对象永不改变，只能复制

String s1="abc";
String s2=s1;
s1+="def";
System.out.println(s1);//abcdef>>>s1新开辟了一块空间存放结果
System.out.println(s2);//abc
String s1="abc";
String s2=s1;
s1+="def";
System.out.println(s1);//abcdef>>>s1新开辟了一块空间存放结果
System.out.println(s2);//abc

String str1=”abc”;
String str2=”abc”;                            str1==str2-->true
String str3=”a”+”bc”;                         str1==tr3-->true
String str4=str1+””;                          str1==str4-->false
Integer i1=12;  Integer i2 =12;               i1==i2-->true
Integer i3=128;  Integer i4=128;              i3==i4-->false
String str1=”abc”;
String str2=”abc”;                            str1==str2-->true
String str3=”a”+”bc”;                         str1==tr3-->true
String str4=str1+””;                          str1==str4-->false
Integer i1=12;  Integer i2 =12;               i1==i2-->true
Integer i3=128;  Integer i4=128;              i3==i4-->false

　　说明：str1的值“abc”放在堆中的常量池中，定义str2时，系统发现字面量”abc”已经在常量池中存在，因此直接将此返回给str2，于是str2和str2共享同一个字面量。创建str3时，编译器会把能够直接计算的值先算出来，因此在编译的时候就发现str3的值是“abc”，于是再将“abc”返回给str3。此时str1,str2,str3共享同一个变量，指向同一个地址。对于str4,编译的时候不能直接计算出它的值，因此需要重新去建一个对象，此时与str1,str2,str3的地址不等

　　对于i3，是Integer对象，但是当其值<=127时，Integer类型的相同值的对象就只有一个。但当其值>=128时，Integer i3=128就相当于Integer i3=new Integer();就是说产生了一个新的对象，这个新的Integer对象肯定会跟i4不同地址。

9. 线程安全与不安全比较：

　　StringBuffer是Java早期提供的（JDK1.0），速度稍慢，线程安全

　　StringBuilder是Java5以后提供的，速度快，线程不安全

　　ArrayList和LinkedList，线程不安全 ----- Vector，线程安全

　　HashMap，不安全 --- HashTable，安全

通过以下代码可以将非线程安全的list包装为线程安全的

List list=new ArrayLsit();
list=Collections.synchronizedList(list);
List list=new ArrayLsit();
list=Collections.synchronizedList(list);

通过以下代码可以将非线程安全的map包装为线程安全的

Map map=new HashMap();
map=Collections.synchronizedMap(map);
Map map=new HashMap();
map=Collections.synchronizedMap(map);

10.下面代码的输出结果是：

String regex="\\\\";//4个“\”
String str2="\\\\\\\\";//8个“\”
String str3=str2.replaceAll(regex, "*");
System.out.println(str3);
String regex="\\\\";//4个“\”
String str2="\\\\\\\\";//8个“\”
String str3=str2.replaceAll(regex, "*");
System.out.println(str3);

　　答案：****

　　解释：字符串中存在转义字符，因此\\\\表示两个斜线，即“\\”，而用在正则表达式中，两个斜线又有一个是转义字符，在正则表达式中就被看成了一个字符“\”。str2其实是4个斜线，因此，用一个斜线作为替换规则，去替换4个斜线，得到4个心号。

11.

public class EJB {
    class a{
       private static int b=12;
       public void print(){
           System.out.println(b);
       }
    }
}
public class EJB {
    class a{
       private static int b=12;
       public void print(){
           System.out.println(b);
       }
    }
}

　　b的声明处报错，The field b cannot be declared static; static fields can only be declared in static or top level types。

　　静态域只能声明在静态或顶层类型中。

12.

BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(“file.dat”));
bos.write(100);
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(“file.dat”));
bos.write(100);

　　假设file.dat不存在，运行该程序段后，文件file.dat的字节数为

　　A.0 B.1 C.2 D.3

　　【选A】。如果不刷新缓冲区，那么写入的字节信息就是写在缓冲区的（也就是内存）。如果显示的调用bos.flush()，或者显示调用bos.close()【bos.close的时候，会自动调用flush方法，清空缓冲区的内容】那么会将缓冲区中的数据写入文件，此时文件就有内容了。

13. 接口java.lang.Comparable<T>

　　此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

　　接口java.util.Comparator<T>

　　强行对某个对象 collection 进行整体排序的比较函数。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

14. InputStream、OutputStream、Reader、Writer都是抽象类。java.util.List extends Collection是接口

15.XML的默认字符集是UTF-8。

16.JavaScript中：

typof(undefined)=undefined; 
typeof(null)=object;

17.解析DOM树时，是从上到下的解析，如果遇到脚本（不是函数，是script之中，function之外的脚本），也依次执行。

18.JS变量没有块级作用域，如果在function中的一个语句块（例如for循环中）定义了一个变量，那么在这个function中，哪怕是出了for的地方，也可以使用这个变量。

19.用select查询rownum的时候，只能使用小于，如果条件是大于，则不会有结果的。

20.下面语句输出什么？

public class T15 {
    public static void main(String[] args) {
        int s=99;
        switch (s) {
        case 0:
            System.out.println();
        default:
            System.out.println("error");
        case 9:
            System.out.println("good");
        case 2:
            System.out.println("best");
        }
    }
}
public class T15 {
    public static void main(String[] args) {
        int s=99;
        switch (s) {
        case 0:
            System.out.println();
        default:
            System.out.println("error");
        case 9:
            System.out.println("good");
        case 2:
            System.out.println("best");
        }
    }
}

　　答案：error, good, best。

　　原因：遇到switch，就依次将可选的值进行比较。这个比较会比较所有的值，不管default在中间还是在最后。如果把除了default的值都比较后，能够找到匹配的，则执行匹配的值的代码。如果之后没有退出（没有break语句），还会依次执行之后的代码。如果没找到匹配的值，那么开始执行default语句。如果之后也没有退出，则还会依次执行default之后的case语句，直到遇到break或者花括号。

21. 如果一个类实现了两个不同的接口，而这两个接口定义了相同的方法时，以下原则不正确的是：( C )

　　A、如果每个接口的两个方法具有相同的方法声明，则在类中实现一个方法，并且该方法同时满足两个接口；

　　B、如果两个方法参数不同，则需要实现两个方法，分别满足各自的接口定义；

　　C、如果两个方法参数相同，但返回类型不同，也需要定义两个不同方法，分别返回不同的类型；

　　D、如果两个方法参数相同，但返回类型不同，则不能创建满足两个接口的方法。

　　解答：C中，不能在一个类里面定义只有返回值相同的两个方法

22.下列有关类继承的说法正确的是：( C )

　　A、基类中定义了private方法A，派生类中不能定义同名的方法；（可以定义）

　　B、基类中定义了protected方法A，派生类中可以重载方法A，并可以将访问级别修改为private；（子类不能减小父类方法的可见性，就是说不能从protected变为private）

　　C、基类中定义了private的变量a，派生类中可以定义同样的变量a，并可以将访问级别修改为public；

　　D、基类中定义了protected静态变量A，派生类中不能定义同样的变量。（可以定义）

23.两种方式添加一个下拉列表项：

1).

document.getElementById(‘s1’).options[i]=
new Option(‘shanghai’,’sh’);

2).

var op=document.createElement(‘option’);
op.value=’sh’;
op.innerHTML=’shanghai’;
document.getElementById(‘s1’).appendChild(op);

24.一个接口可以继承于多个接口

25. 一个抽象类可以继承于一个普通类

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：mysql 可以监控到表的读写量吗

下一篇：design modeler 复制

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

java如何向量化数据

java如何向量化数据

51CTO博客