精华内容
下载资源
问答
  • 1.3.1 Java的关键字 Java关键字: oracle对java关键字的描述. Java明确有50个关键字,其中有两个是仍未使用的:goto和const。 现在正在使用的Java关键词只有48个。...控制流程和循环的:do,while,if ,f


           Author: 兴趣使然的程序猿

    1.3.1 Java的关键字

           Java关键字: oracle对java关键字的描述.
           Java明确有50个关键字,其中有两个是仍未使用的:goto和const。现在正在使用的Java关键词只有48个。
           这样想编程语言是不是很简单呢!我们记的英文单词几千甚至上万,而Java只要学会了这48个关键词的使用就掌握了Java的所有用法,是不是so easy!
    Java关键字


    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字符串的压缩机制都没有谈到…就此抛砖引玉

    欢迎一键三连兴趣使然的程序猿

    展开全文
  • and assume further that thread t1 is trying to assign value v1 to shared while t2 is trying to assign it value v2. Is it guaranteed that shared will wind up with either v1 or v2 when the threads ...
  • 使用类锁的情况:是所有线程共享的锁,所以同一时刻,只能有一个线程使用加了锁的方法或方法体,不管是不是同一个实例都只允许一个线程访问. 买票问题解决方案: 1.使用synchroized锁对象: 1.1使用this关键字: 售票类:...

       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+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 关键字 空格 条件 冒号 缩进 循环体 break 终止continue 跳出本次循环,继续下次循环条件 可以控制while循环 格式化输出 msg = '你好%s,我是%s'%('乔狗','你大哥') print(msg) %s %d== %i 占位 d和i...

    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

    展开全文
  • 大家不要把这个题想太难,它并没有让判断是不是关键字。。。 #include #include int main() {  int i,f,l,n;  char s[55];  while(scanf("%d",&n)!=EOF)  {  getchar();  while(n--){  gets(s
  • 我文件里存的是java关键字,然后判断是不是关键字,可是弄了半天都是false,然后我试了一下,如下 System.out.print(keywords[0]); if(keywords[0]=="abstract") return true; 然后print出来的是abstract,但...
  • 下面的单词,很眼熟吧,是不是感觉很多语言都有呢,哎,条条大路通罗马,仅从关键字和保留字就可窥之一二 对应用法持续补充中 一.关键字(keyword)  break  else new var case  finally  return ...
  • 这里笔者告诉您一个技巧,如果您在看代码过程中,看到特殊的字符感觉不是关键字也不是函数,那您首先要想到的就是:这个东西是不是#define或者typedef过的呢? 直接开门见山,比如ACM比赛经常有这样的代码:while...
  • 求1+2+3+...+n

    2017-08-22 21:55:08
    题目求1+2+3+…+n,要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句(A?B:C)。思路使用递归,由于递归需要终止条件,可以使用传入的参数是不是0来判断。参考代码class Solution { ...
  • continue: 在循环中如果遇到continue关键字,直接开始下一次循环 例1:求100-200之间所有奇数的和(用continue) var sum=0; var i=100; while(i<=200){ //判断是不是偶数 if(i%2==0){ //如果是偶数→跳过这个...
  • js基础第三天

    2019-03-08 23:55:30
    在循环中如果遇到continue关键字,直接开始下一次循环 leg //案例:求100-200之间所有的奇数的和(用continue) // var sum=0; // var i=100; // while(i&lt;=200){ // //判断是不是偶数 // if(i%2==0){ // //...
  • 刷题_DAY2

    2018-03-09 09:46:42
    1.根据前序遍历和中序遍历的结果重建二叉树。2.判断某一数组是不是二叉查找(搜索)树的后续遍历。3.求二叉树的深度-&...求1+2+....+n,不能用乘除法、for、while、if、else、switch、case等关键字及条件判断语句...
  • 求 1+2+…+n ,要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句(A?B:C)。 示例 1: 输入: n = 3 输出: 6 示例 2: 输入: n = 9 输出: 45 限制: 1 <= n <= 10000 思路: 很...
  • 需要注意的是,删除后原来位置的元素发生了改变,所以还要再检查一次当前位置的元素是不是要检查的字符,否则如果有多个连续的关键字,会留下一些没删掉。 #include &lt;stdio.h&gt; void delcharfun(char *...
  • 求1+2+3+...+n的和

    2018-09-23 22:11:49
    题目描述:求1+2+3+…+n,要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句(A?B:C)。 解法1: 巧妙利用逻辑运算符的短路原则,代码如下: 代码中如果ans是0则结束递归,返回...
  • 题目描述:求1+2+3+...+n,要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句(A?B:C)。 看着这么恶心,递归是不是就行了?但是没有if没法设出口,不行不行 偷偷默默看了网友代码。...
  • 求1+2+3+...+n,要求不能使用乘除法,for,while,if,else,switch,case等关键字及条件判断语句(a?b:c)。 思路: 1、构造函数 在类中定义静态成员变量N和sum,在构造函数中++N,sum+=N;如此一来,创建n个该类型的...
  • 题目:求1+2+…+n,要求不能使用乘除法、for、while、if、else、switch、case 等关键字以及条件判断语句(A?B:C) 不能使用的东西囊括了基本的编程工具, 先来看看能使用的方法有哪些,加减法、位移(左右移操作...
  • 有这样的二层表结构,父表users,子表books.需要在显示books的时候,显示user的username,而不是user_id. 请问如何才能在下面的view代码中显示到username...是不是要在model中添加些什么才行? 还是因为user是关键字
  • //传过来 的查询内容,即查询关键字。 } public void run(){ //根据ip创建相应的web Service并通过它进行远程方法调用 String url= ip+"SearchForYou/services/SearchCell"; //构建 ...
  • if(y9==EOF){ //判断scanf录入的是不是字母 printf("输入有误!请重新输入\n"); k9=1; } if(i9||i9>300){ printf("输入有误!请重新输入\n"); k9=1; } } return i9; } /...
  • 事件是不是一种委托? 答 : 委托可以把一个方法作为参数代入另一个方法。 委托可以理解为指向一个函数的引用。 是,是一种特殊的委托 5.override与重载的区别 答 : override 与重载的区别。重载是方法的...
  • 简易编译器

    2013-06-03 09:59:00
    error = "该程序缺少关键字:program"; } } #endregion #region 程序体 private void ProBody() { if (tokens[i].Code == 16) { Next(); VarDef(); } else if (tokens[i].Code == 2) { Next(); ...
  • 要求不能使用乘除法、for、while、if、else、switch、case等关键字以及条件判断语句(A?B:C) C#求解(与C,C++思路不同的另一种思路) private int Fact(int n) { //1+2+…+n=n*(n+1)/2=(n^2+n)/2; int[,] array=...
  • java面试800题

    2011-09-13 20:25:48
    int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while....
  • 疯狂JAVA讲义

    2014-10-17 13:35:01
    学生提问:使用组合关系来实现复用时,需要创建两个Animal对象,是不是意味着使用组合关系时系统开销更大? 159 5.9 初始化块 159 5.9.1 使用初始化块 160 5.9.2 初始化块和构造器 161 5.9.3 静态初始化块 162 ...

空空如也

空空如也

1 2 3
收藏数 55
精华内容 22
关键字:

while是不是关键字