Java关键字和String源码解析
1.3.1 Java的关键字
1.3.2 Java关键字分类
1.3.3 String是不是关键字
1.3.4 String源码
1.3.5 String重写的equals方法
1.3.6 为什么要重写hashCode方法呢？
1.3.7 小结


       Author:  兴趣使然的程序猿

1.3.1 Java的关键字
       Java关键字: oracle对java关键字的描述.

       Java明确有50个关键字，其中有两个是仍未使用的：goto和const。现在正在使用的Java关键词只有48个。

       这样想编程语言是不是很简单呢！我们记的英文单词几千甚至上万，而Java只要学会了这48个关键词的使用就掌握了Java的所有用法，是不是so easy！






1.3.2 Java关键字分类
       控制访问权限的如private，protect，public，static

       控制流程和循环的：do，while，if ，for，swich，case，continue，break

       修饰或定义类和接口的：class，interface，enum，abstract，final

       父类实现关系的：extends，implement，super，this

       异常处理的：try，catch，throw，throws

…

       其他还有基本类型啊，同步的一些关键字，总结下来就这些，并且关键字都是小写的。




1.3.3 String是不是关键字
       那么String是不是关键字呢，想必大家都没有疑问了吧！肯定不是滴。

       那就来看下String的源码吧！




1.3.4 String源码
       首先String是一个final类，定义成final类那么String当然是不可以被继承的（知识点）。看到它实际存储的是一个char 类型的字符数组。

       还有一个int hash，并且hash默认是0，这个是做什么的呢？
/** The value is used for character storage. */
private final char value[];

/** Cache the hash code for the string */
private int hash; // Default to 0

/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;


       找到String处理变量hash的地方如下：
public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

       终于找到啦，原来这个变量就是hash就是这个字符串的hashCode啊！

       通过公式可以得出该计算公式如下
//公式  h = char[i]+ 31h

       如有字符串"abc"，字符串中取的是该字符的char值Unicode编码大小，那么该hashCode结果就是a * 32^2  + b*32^1 + c。
       问题：是不是两个不同字符串hashCode就一定不相同?
       当然不是啦，通过上边的公式我们就很容易的可以找出来这样的列子，如"ab"和"bC"。




1.3.5 String重写的equals方法
       先比较是否是同一个对象，是的话一定相同。如果不是的话然后再比教长度，最后比较每一个字符是否都相等，都满足则返回true，由此可见这就是为什么比较字符串为什么要用equals方法了，它解决的问题就是当两个字符串存储位置不一样时也可能时相同的字符串。
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}




1.3.6 为什么要重写hashCode方法呢？
       明明只需要重写equals就可以比较了呢？
       个人实验的理解：

       1.首先这个是符合Java规范的，当两个对象相同时，那么其hashCode一定需要相同，反之则不然。

       2.错误的重写hashCode在使用集合类时会产生错误，因为String类重写了equals方法，当对象相等时hashCode相同时Java世界的法则，所以String重写hashCode方法时必要的，不这样使用集合时就可能会产生冲突，实际代码为例子
    private static class Test {

        public String value;

        public Test(String value) {
            this.value = value;
        }

        @Override
        public int hashCode() {
            int h = 0;
            if (h == 0 && value.length() > 0) {
                char val[] = value.toCharArray();

                for (int i = 0; i < value.length(); i++) {
                    h = 31 * h + val[i];
                }
            }
            return h;
        }

        @Override
        public boolean equals(Object obj) {
            return hashCode() == obj.hashCode();
        }

        @Override
        public String toString() {
            return "Test{" +
                    "value='" + value + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        System.out.println((int)'a');
//        System.out.println((char)(31*'a'+'b'-31*'b'));
        String ab = "ab";
        String bx = "bC";
        Test test1 = new Test(ab);
        Test test2 = new Test(bx);
        Map<Test, String> map = new HashMap<>();
        map.put(test1,"ab");
        map.put(test2,"bC");
}

       重写test类的hashCode()方法和equals()方法，将两个类的实列作为key放进一个hashMap里，最后发现结果:
{Test{value='ab'}=bC}

       只剩下一个元素了，这就是Java里的规则，equals是描述两个相同实列的方法，当不恰当重写就会出现很多问题，String重写则是因为假设有两个"aa"字符串实列，但是他们相同的，只是存储位置不一样。



1.3.7 小结
       花了不少时间阅读源码，这次算终于比较深入的了解String字符串了，其中也还有些许问题并没有写出，如为什么String 的hashCode()方法为什么用31作为相乘因子呢？比如，String各种构造函数的方法？还有String字符串的压缩机制都没有谈到…就此抛砖引玉
欢迎一键三连，兴趣使然的程序猿

   synchroized关键字总结:

      类锁:

         synchronized(类.class){…}

         synchronized修饰静态方法

      对象锁:

         synchronized(this){…}

         synchronized(自定义内部对象实例){…}

         synchronized修饰普通方法

   使用对象锁的情况:所有的线程共用一个对象实例才会保证线程安全.我的理解是同一对象实例才能保证锁是唯一.

   使用类锁的情况:是所有线程共享的锁(就是所有线程共享一把类锁)，所以同一时刻，只能有一个线程使用加了锁的方法或方法体，不管是不是同一个实例都只允许一个线程访问.

   卖票问题解决方案:

1.使用synchroized锁对象:

1.1使用this关键字:

售票类:
public class SaleTicket {
    private static int ticketCount=100;

    public void saleTicket(){
     while (ticketCount>0){
         // 锁对象:synchronized (this){}
        synchronized (this){
            if (ticketCount > 0){
                System.out.println(Thread.currentThread().getName()+"买了第"+ticketCount+"张票");
                --ticketCount;
            }else {
                System.out.println("票卖完了");
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    }
}

线程类:
public class TicketThread extends Thread{

    private SaleTicket saleTicket;

    public TicketThread(SaleTicket saleTicket) {
        this.saleTicket=saleTicket;
    }

    @Override
    public void run() {
        saleTicket.saleTicket();
    }
}

测试类:
public static void main(String[] args) {
    SaleTicket saleTicket = new SaleTicket();
    new TicketThread(saleTicket).start();
    new TicketThread(saleTicket).start();
}

1.2使用自定义内部对象实例:

售票类:
public class SaleTicket {
    private static int ticketCount=100;
    private Object obj=new Object();

    public void saleTicket(){
     while (ticketCount>0){
         // 锁对象,自定义对象
         synchronized (obj) {
             if (ticketCount > 0) {
                 System.out.println(Thread.currentThread().getName() + "买了第" + ticketCount + "张票");
                 --ticketCount;
             } else {
                 System.out.println("票卖完了");
             }
             try {
                 Thread.sleep(50);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
    }
    }
}

测试类与线程类同上

1.3普通方法上使用synchronized关键字(相当于是锁对象):

售票类:
public class SaleTicket {
    private static int ticketCount=100;

    public synchronized void saleTicket(){
     while (ticketCount > 0){
         if (ticketCount > 0){
             System.out.println(Thread.currentThread().getName()+"买了第"+ticketCount+"张票");
             --ticketCount;
         }else {
             System.out.println("票卖完了");
         }
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
    }
    }
}

测试类与线程类同上

1.使用synchroized锁类:

2.1使用synchroized(类名.class)锁类:
public class SaleTicket {
    private static int ticketCount=100;
    public void saleTicket(){
     while (ticketCount>0){
         synchronized (SaleTicket.class){
            if (ticketCount > 0){
                System.out.println(Thread.currentThread().getName()+"买了第"+ticketCount+"张票");
                --ticketCount;
            }else {
                System.out.println("票卖完了");
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    }
}

线程类和测试类同上

2.2静态方法上使用synchronized关键字(相当于是锁类):

售票类:
public class SaleTicket {
    private static int ticketCount=100;

    public static synchronized void saleTicket(){
     while (ticketCount > 0){
         if (ticketCount > 0){
             System.out.println(Thread.currentThread().getName()+"买了第"+ticketCount+"张票");
             --ticketCount;
         }else {
             System.out.println("票卖完了");
         }
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
    }
    }
}

线程类:
public class TicketThread extends Thread{

    private static int ticketCount=100;

    @Override
    public void run() {
        //saleTicket.saleTicket();
        SaleTicket.saleTicket();
    }

}

测试类:
public static void main(String[] args) {
    new TicketThread().start();
    new TicketThread().start();
}

   关于使用synchronized关键字之后本地模拟出现多线程中只有一个线程完成所有任务的情况,一般是和CPU有关,本场景中可以增到票数.

   如有描述不当之处,还望指正,期待发现问题,解决问题!

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
是不是老阔疼，想用递归，但是有for又不行，抓狂！
别慌，我们来分析分析，既然乘除用不了，那么n^2+n肯定是行不通的。再想想，除了上述方法之外，还有没有其他的好方法。

一般会想到从1往上加，但问题是边界问题，也就是什么时候截止的问题。n的界限不好确定，所以我们倒着来，以0为界限，从n往下加。
代码如下：
public class Solution {
	public static void main(String[] args) {
		System.out.println("请输入n的值");
		Scanner s = new Scanner(System.in);//从键盘输入
        int n=s.nextInt();  
        int r=sum(n);  
        System.out.print(r);  
          
    }  
    public static int sum(int n){  
        int r=0;  
        boolean ans=false;//如果ans为false,则执行下一步
        int a=0; // 界限
        ans=(n!=0)&&(a==(r=sum(n-1)));  //n不为0这个为真，但是a不等于后面的，
        //所以结果为假，返回r+n，继续执行，结果为假，返回n-1，实现从n一直加到0；
        return r+n;  
    }
}

输出结果



欢迎大家留言讨论！

    
while循环
格式：
while 关键字 空格 条件 冒号
缩进 循环体
break 终止
continue 跳出本次循环,继续下次循环
条件 可以控制while循环
格式化输出

msg = '你好%s,我是%s'%('乔狗','你大哥')
    print(msg)

%s  %d== %i 占位   d和i必须放入的是整型  %s是不是放任何东西
数量要对应
	在格式化中使用%的时候需要转义  %%
运算符
比较运算符
	>  <  >=  <=  ==  !=
	赋值运算符
	+=  -=  *=  /=  //=  **=  %=
	成员运算符
	in  not  in
	逻辑运算符
	and  or  not
	算数运算符
	+  -  *  /  **  %  //
初识编码
ascii 美国 256 没有中文 
		一个字节  8位    
	gbk 中国   
		中文 2字节  16位 
		英文 1字节  8位
	unicode 万国码  
		2个字节     16位
		4个字节     32位
	utf-8 可变编码    
		英文 1字节  8位
		欧洲 2字节  16位
		亚洲 3字节  24位
单位转化
	# bit 位
	# bytes 字节
	# 1B == 8bit
	# 1024B = 1kB
	# 1024kB = 1MB
	# 1024MB = 1GB
	# 1024GB = 1TB
 
我们来做一些案例
判断下列逻辑语句的True,False
1）1 > 1 or 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6　　　　　　　　　　　　　　　　　　True
2）not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 　　　　　　　　　　　　　　　False
求出下列逻辑语句的值
1),8 or 3 and 4 or 2 and 0 or 9 and 7　　　　　　　　　　　　　　　　　　　　　　　　　　8
2),0 or 2 and 3 and 4 or 6 and 0 or 3　　　　　　　　　　　　　　　　　　　　　　　　　　4
求下列结果
 
1)、6 or 2 > 1　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　6　　
 
2)、3 or 2 > 1　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　3
 
3)、0 or 5 < 4　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　False
 
4)、5 < 4 or 3　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　3
 
5)、2 > 1 or 6　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　True
 
6)、3 and 2 > 1　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 True
 
7)、0 and 3 > 1　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 0
 
8)、2 > 1 and 3　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 3
 
9)、3 > 1 and 0　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 0
 
10)、3 > 1 and 2 or 2 < 3 and 3 and 4 or 3 > 2　　　　　　　　　　　　　　　　　   2
 
 
利用while语句写出猜大小的游戏
设定一个理想数字比如：66，让用户输入数字，如果比66大，则显示猜测的结果大了；如果比66小，则显示猜测的结果小了;只有等于66，显示猜测结果正确，然后退出循环。
 

num=66
while 1:
    num1 = int(input("请输入你的猜想："))
    if num1>num:
        print("猜大了")
    elif num1<num:
        print("猜小了")
    else:
        print("猜对了")
        break

 
对以上的题进行升级
给用户三次猜测机会，如果三次之内猜测对了，则显示猜测正确，退出循环，如果三次之内没有猜测正确，则自动退出循环，并显示‘太笨了你....’。
 

num=66
count=1
while count<=3:
    num1 = int(input("请输入你的猜想："))
    if num1>num:
        print("猜大了")
        count+=1
    elif num1<num:
        print("猜小了")
        count+=1
    else:
        print("猜对了")
        break
    if count>3:
        print("太笨了你")

 
使用while循环输出 1 2 3 4 5 6 8 9 10

sum=1
while sum<11:
    if sum!=7:
        print(sum)
    sum+=1

求1-100的所有数的和

sum=0
count=1
while count<101:
    sum+=count
    count+=1
print(sum)

输出 1-100 内的所有奇数

count=1
while count<101:
    print(count)
    count+=2

输出 1-100 内的所有偶数

count=0
while count<100:
    count+=2
    print(count)

求1-2+3-4+5 ... 99的所有数的和
第一种写法：

sum = 0
count = 1
while count < 100:
    if count % 2 == 1:
        sum += count
        count += 1
    else:
        sum -= count
        count += 1
print(sum)

第二种写法：

sum = 0
count = 1
while count < 100:
    if count % 2 == 1:
        sum += count
    else:
        sum -= count
    count += 1
print(sum)

第三种写法：

1 i=0                #作为循环的的值
2 sum=0           #作为最后打印总值
3 j=-1               #作为运算时的符号
4 while i<99:
5     i+=1           #i自加1
6     j=-j             #此处把符号变换     
7     sum+=i*j     #sum等于i的值乘以符号，达到变号
8 print(sum)         #打印sum                     

⽤户登陆（三次输错机会）且每次输错误时显示剩余错误次数

uname="乔狗"
upassword="666"
count=3
while count>0:
    username=input("输入你的用户名：")
    userpassword=input("输入密码：")
    if username==uname and userpassword==upassword:
        print("登录成功")
        break
    else:
        print("用户名或密码错误，你还有%s次机会" % (count-1))
        count-=1

 
 
 
 
 
 
 

转载于:https://www.cnblogs.com/53Dawns/p/10192914.html