java基础知识总结

/*
java基础语言总结

*/

1.基本数据类型有哪些
byte short boolean char int float long double
//测试基本数据类型所占用的字节数,可以通过其包装类进行实现
System.out.println("byte的大小"+Byte.SIZE/8);
System.out.println("short的大小"+Short.SIZE/8);
System.out.println("char的大小"+Character.SIZE/8);
System.out.println("int的大小"+Integer.SIZE/8);
System.out.println("float的大小"+Float.SIZE/8);
System.out.println("double的大小"+Double.SIZE/8);
System.out.println("long的大小"+Byte.SIZE/8);

输出如下：
byte的大小1
short的大小2
char的大小2
int的大小4
float的大小4
double的大小8
long的大小1

java中支持类型向上转型，低精度的可以直接转化为高精度的，但是高精度的转化为低精度的必须强转
如：float int double 之间的相互转化

float f=3.14f;
int f1=(int)f;
System.out.println(f1);
double d=f;
System.out.println(d);

double d1=3.16478263482364832;
float f2=(float)d1;
System.out.println(f2);

int a=3;
double d2=a;
System.out.println(d2);

//了解逻辑运算中的短路与和与

&& 此为短路与，&为与

&&：当条件的左端已经判断为false的时候，有端不需要进行判断就可以跳出

&必须判断两端的情况，不管是否左边为false

public static void main(String [] args){
int a=2;
int b=5;
long flag=10000000;
long time=System.currentTimeMillis();
while(flag!=0){
if(a==3&b==5){
System.out.println("输出的为正确");
}
flag--;
}
long temptime=System.currentTimeMillis();

System.out.println(temptime-time); // 15

while(flag!=10000000){
if(a==3&&b==5){
System.out.println("输出的为正确");
}
flag++;
}
long endTime=System.currentTimeMillis();
System.out.println(endTime-temptime); // 0
}


1.1String 类 StringBulider StringBuffer
String类：
String s="abc";
String s1="abc";
System.out.println(s1==s); //true

当String对象为字符串常量的时候，java虚拟机将会将此字符串放到字符串常量池中作为缓存，
当定义另外一个字符串常量时，jvm将会在常量池中先查找是否存在这个常量，如果存在将会把地址给
栈中的引用变量，没有将会在常量池中产生一个新的对象，并把地址交给栈中的引用变量。

String s1="abc";
String s2="abcd";
String s3=s1+s2;
String s4="abc"+"abcd";

System.out.println(s3==s4)//false

//返回对象的hashCode
System.identityHashCode(s3);

s3是先取得s1和s2在常量池中的值，再进行拼接。
而s4是在编译时就将字符串进行了拼接，之后在常量池中就创建了这个新的对象

可以通过java反编译看看字节码文件 ，就可以在常量池中存在此常量 javap -v BasicDataType.class 

从上面反编译中，我们可以看出在常量池中已经重新建立了一个abcabcd的对象，下面将通过jvm的操作指令来解释如何将这个对象交给s4的

idc #39 将#39这个地址中的内容从常量池中压入栈中，而这个地址指向的是#40这个地址，所以将常量abcabcd压入栈中

而astore的意思是将栈顶的数弹出保存到本地变量5中，刚好就是S4 因为main函数中有一个参数args

 

String类常用方法

     常用的构造方法：         

     String() --------- 初始化一个String对象，表示一个空字符序列

     String(String value) --------- 利用一个直接量创建一个新串

     String(char[] value) --------- 利用一个字符数组创建

     String(char[] value,int offset,int count) --------- 截取字符数组，从offset开始count个字符创建

     String(StringBuffer buffer) --------- 利用StringBuffer创建

 　 

 

    常用方法讲解：

      compareTo(String anotherString)

      

       String str="xiaolinihao";
       
       String str1="xiaoli";
       
       System.out.println(str.compareTo(str1));  //此时返回5
       

　　

         String str="xiaozhou";

         String str1="xiaoli";

         System.out.println(str.compareTo(str1)); //此时返回14

           笔者当时很不明白，上面两种结果到底是怎么来的，下面我们将从源码的角度解释为什么会出现以下的结果

int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

         从源码中，我们可以看到比较两个字符串的大小是取其相同的长度进行比较，相同长度的部分如果出现不同的值，那么将会返回对应位置的ascll码的差值，如果比较都相同则返回其字符串长度的差值。

 indexof(String str,int fromIndex)

  public int indexOf(String str, int fromIndex) {
        return indexOf(value, 0, value.length,
                str.value, 0, str.value.length, fromIndex);
    }

static int indexOf(char[] source, int sourceOffset, int sourceCount,char[] target, int targetOffset, int targetCount,int fromIndex)
{
    if (fromIndex >= sourceCount) {
    return (targetCount == 0 ? sourceCount : -1);
    }
    if (fromIndex < 0) {
    fromIndex = 0;
    }
   if (targetCount == 0) {
   return fromIndex;
   }

   char first = target[targetOffset];
   int max = sourceOffset + (sourceCount - targetCount);      

   //如果目标字符串为 xiao   源字符串是hellozhouxia  它们之间长度的差值为8                                                      

   //当源字符串判断到第9个字符u时，还是与x不想同，那么久不需要再判断了，因为目标字符串为4位，而

   //源字符串只剩下三位，是不可能和目标字符串相同的

   for (int i = sourceOffset + fromIndex; i <= max; i++) {     //当第一次只有一个字符相同，但是后面有字符不一致的时候，这个循环就起作用了
   /* Look for first character. */
   if (source[i] != first) {                                   //将会从第i个位置继续匹配第一个是否相同，如果相同继续进行匹配第二个字符
   while (++i <= max && source[i] != first);        //当目标字符串的第一个字符与原字符串相同时跳出while循环
   }

   /* Found first character, now look at the rest of v2 */    //匹配下一个字符是否相同
   if (i <= max) {
   int j = i + 1;
   int end = j + targetCount - 1;         
   for (int k = targetOffset + 1; j < end && source[j]
   == target[k]; j++, k++);

   if (j == end) {
   /* Found whole string. */
   return i - sourceOffset;                                //此时匹配到了整个字符串，输出的是源字符串中相同字符串中的第一个字符的位置

    }
 }

}
return -1;       //匹配不成功的时候将会返回-1
}