实习期间Java知识点整理（continue、length和length()的区别、clear()、equals和==、队列queue、this关键字）

最新推荐文章于 2021-02-16 19:59:32 发布

玥栎今天更新了吗

最新推荐文章于 2021-02-16 19:59:32 发布

阅读量521

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_44131010/article/details/97917043

版权

Java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

Java continue语句详解

continue 语句是跳过循环体中剩余的语句而强制执行下一次循环，其作用为结束本次循环，即跳过循环体中下面尚未执行的语句，接着进行下一次是否执行循环的判定。

continue 语句类似于 break 语句，但它只能出现在循环体中。它与 break 语句的区别在于：continue 并不是中断循环语句，而是中止当前迭代的循环，进入下一次的迭代。简单来讲，continue 是忽略循环语句的当次循环。

注意：continue 语句只能用在 while 语句、for 语句或者 foreach 语句的循环体之中，在这之外的任何地方使用它都会引起语法错误。

java中length和length()的区别

在java中String类可以定义字符串变量和字符串数组，
length()用于求String字符串对象的长度，而length用于求String字符串数组的长度。
length()是求String字符串对象中字符的个数，而length是求字符串数组中有多少个字符串。
他们的用法为：

此代码输出结果为 7 4.
如果想求s2[0]字符串的长度代码可写：t2 = s2[0].length() 即可，即melon的长度，若输出t2的结果则为5.
在这里插入图片描述
作者：一叶知秋-
原文：https://blog.csdn.net/qq_37962204/article/details/78170824

java中的clear()

用来清除数组中，或者列表中的数据的
为了避免数据的叠加。就需要在加载前用数组.clear()；清除数据

public Tree(Object data) {  
            this.data = data;  
            childs = new ArrayList();  
            childs.clear();  
        }

java中的equals和==

有两种用法说明:
一、对于字符串变量来说，使用 “==”和“equals()”方法比较字符串时，其比较方法不同。

1."==”比较两个变量本身的值，即两个对象在内存中的首地址。比较的是类型是否一样。
(java中，对象的首地址是它在内存中存放的起始地址，它后面的地址是用来存放它所包含的各个属性的地址，所以内存中会用多个内存块来存放对象的各个参数，而通过这个首地址就可以找到该对象，进而可以找到该对象的各个属性)
2、“equals()”比较字符串中所包含的内容是否相同。

java中的队列queue

1.队列的特点
队列是一种比较特殊的线性结构。它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。
队列中最先插入的元素也将最先被删除，对应的最后插入的元素将最后被删除。因此队列又称为“先进先出”（FIFO—first in first out）的线性表，与栈(FILO-first in last out)刚好相反。
2.java中的队列
java中的Queue接口就实现了队列的功能。
Queue的实现类有LinkedList和PriorityQueue。最常用的实现类是LinkedList。

Queue的6个方法分类：

压入元素(添加)：add()、offer()
相同：未超出容量，从队尾压入元素，返回压入的那个元素。
区别：在超出容量时，add()方法会对抛出异常，offer()返回false

弹出元素(删除)：remove()、poll()
相同：容量大于0的时候，删除并返回队头被删除的那个元素。
区别：在容量为0的时候，remove()会抛出异常，poll()返回false

获取队头元素(不删除)：element()、peek()
相同：容量大于0的时候，都返回队头元素。但是不删除。
区别：容量为0的时候，element()会抛出异常，peek()返回null。

Queue 接口并未定义阻塞队列的方法，而这在并发编程中是很常见的。BlockingQueue 接口定义了那些等待元素出现或等待队列中有可用空间的方法，这些方法扩展了此接口。

Queue 实现通常不允许插入 null 元素，尽管某些实现（如 LinkedList）并不禁止插入 null。即使在允许 null 的实现中，也不应该将 null 插入到 Queue 中，因为 null 也用作 poll 方法的一个特殊返回值，表明队列不包含元素。

Queue 实现通常未定义 equals 和 hashCode 方法的基于元素的版本，而是从 Object 类继承了基于身份的版本，因为对于具有相同元素但有不同排序属性的队列而言，基于元素的相等性并非总是定义良好的。

public class QueueTest {
 public static void main(String[] args) {
Queue<String> queue = new LinkedList();
queue.offer("元素A");
 queue.offer("元素B");
queue.offer("元素C");
 queue.offer("元素D");
queue.offer("元素E");
while (queue.size() > 0) {
String element = queue.poll();
System.out.println(element);
 }
   }
  }

结果：
素A
元素B
元素C
元素D
元素E
    
Process finished with exit code 0

示例2：

    import java.util.LinkedList;
    import java.util.Queue;
     
    public class Main {
        public static void main(String[] args) {
            //add()和remove()方法在失败的时候会抛出异常(不推荐)
            Queue<String> queue = new LinkedList<String>();
            //添加元素
            queue.offer("a");
            queue.offer("b");
            queue.offer("c");
            queue.offer("d");
            queue.offer("e");
            for(String q : queue){
                System.out.println(q);
            }
            System.out.println("===");
            System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
            for(String q : queue){
                System.out.println(q);
            }
            System.out.println("===");
            System.out.println("element="+queue.element()); //返回第一个元素 
            for(String q : queue){
                System.out.println(q);
            }
            System.out.println("===");
            System.out.println("peek="+queue.peek()); //返回第一个元素 
            for(String q : queue){
                System.out.println(q);
            }
        }
    }

结果

    a
    b
    c
    d
    e
    ===
    poll=a
    b
    c
    d
    e
    ===
    element=b
    b
    c
    d
    e
    ===
    peek=b
    b
    c
    d
    e

如果要求队列深度

int queueDepth=queue,getCurretDepth();
logger.info("队列深度为"+queueDepth);

原文：https://blog.csdn.net/devnn/article/details/82591349
https://www.runoob.com/java/data-queue.html
https://blog.csdn.net/bitcarmanlee/article/details/84666604

Java中的this关键字

首先，this关键字指向的是当前对象的引用

作用：
this.属性名称
指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）

this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this，并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。

class Test_08{
	public static void main(String [] args){
		//调用无参构造函数，
		Person p1 = new Person();
		p1.setAge(20);
		p1.setName("张三");
		p1.setGender("男");
		System.out.println(""+p1.getName()+" 今年"+p1.getAge()+"岁 性别为："+p1.getGender());
	}
	
}
class Person{
	private String name;
	private int age;
	private String gender;
	Person(){}
	Person(String name,int age,String gender){
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	public void setName(String name){
		name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		age = age;
	}
	public int getAge(){
		return age;
	}
	public void setGender(String gender){
		gender = gender;
	}
	public String getGender(){
		return gender;
	}
}

在这里插入图片描述
注意：java中为什么在static中不能使用this关键字

Static方法是类方法，先于任何的实例（对象）存在。即Static方法在类加载时就已经存在了，但是对象是在创建时才在内存中生成。而this指代的是当前的对象.

在方法中定义使用的this关键字,它的值是当前对象的引用.也就是说你只能用它来调用属于当前对象的方法或者使用this处理方法中成员变量和局部变量重名的情况.

而且,更为重要的是this和super都无法出现在static 修饰的方法中,static 修饰的方法是属于类的,该方法的调用者可能是一个类,而不是对象.如果使用的是类来调用而不是对象,

则 this就无法指向合适的对象.所以static 修饰的方法中不能使用this.

例1. 把this作为参数传递

当你要把自己作为参数传递给别的对象时，也可以用this。如：

public class A{

public A(){
    new B(this).print();
}

public void print(){
      System.out.println("From A!");
 }

public static void main(String[] args) {
      new A();
   }
}
 
public class B{
   A a;
   public B(A a){
      this.a = a;
   }
 
   public void print(){
      a.print();
      System.out.println("From B!");
   }
}

运行结果：

From A!
From B!

在这个例子中，对象A的构造函数中，用new B(this)把对象A自己作为参数传递给了对象B的构造函数。

例2. 注意匿名类和内部类中的中的this。

有时候，我们会用到一些内部类和匿名类，如事件处理。当在匿名类中出现this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。如下面这个例子：

public class C {
   int i = 1;
   public C(){
      Thread thread = new Thread(){
        public void run(){
           for(;;){//表示是死循环
              C.this.run();//调用外部方法run()
              try {
                 sleep(1000);
              } catch (InterruptedException e) {
                 e.printStackTrace();
              }
           }
        }
      };//注意这里有分号;
      thread.start();
   }

   public void run(){
      System.out.println("i = " + i);
      i++;
   }

   public static void main(String[] args) throws Exception {
      new C();
   }
}

运行结果：每一秒产生一个数：1,2,3 ……

在上面这个例子中, thread 是一个匿名类对象，在它的定义中，它的 run 函数里用到了外部类的 run 函数。这时由于函数同名，直接调用就不行了。这时有两种办法，一种就是把外部的 run 函数换一个名字，但这种办法对于一个开发到中途的应用来说是不可取的。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。

例3、this关键字最大的作用是，让类的一个方法，访问该类的另一个方法或者属性。

先看一个不好的例子:

public class Baby{

   public void wakeUp(){
      System.out.println("宝宝醒啦");
   }

   public void eat(){
      Baby baby = new Baby();
      baby.wakeUp();
      System.out.println("吃东西");
   }
}

这样不符合逻辑。这就相当于本对象的eat方法，需要调用另一个对象的wakeUp方法。

我们看这个例子:

public class Baby{

   public void wakeUp(){
      System.out.println("宝宝醒啦");
   }

   public void eat(){
      this.wakeUp();
      System.out.println("吃东西");
   }
}

这样就符合逻辑了。自己的eat方法，还需要自己的一个wakeUp方法。

java允许同一个对象的方法直接调用该对象的属性或者方法，所以this可以省略。
原文：https://www.cnblogs.com/zheting/p/7751752.html
https://blog.csdn.net/weixin_42386014/article/details/81138684

玥栎今天更新了吗

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
实习期间Java知识点整理（continue、length和length()的区别、clear()、equals和==、队列queue、this关键字）

Java continue语句详解continue 语句是跳过循环体中剩余的语句而强制执行下一次循环，其作用为结束本次循环，即跳过循环体中下面尚未执行的语句，接着进行下一次是否执行循环的判定。continue 语句类似于 break 语句，但它只能出现在循环体中。它与 break 语句的区别在于：continue 并不是中断循环语句，而是中止当前迭代的循环，进入下一次的迭代。简单来讲，cont...
复制链接

扫一扫