java知识

最新推荐文章于 2022-05-04 20:21:13 发布

王竹根

最新推荐文章于 2022-05-04 20:21:13 发布

阅读量145

点赞数

分类专栏： java学习笔记文章标签： java学习笔记

本文链接：https://blog.csdn.net/dianziagen/article/details/83658353

版权

java学习笔记专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1.计算机中的数据都是以二进制的补码形式存在的（掌握）

需要记住byte的范围：-128 ——127
byte 1, short 2, int 4, long 8, float 4, double 8
数据类型转换-隐式转换
byte，short，char不会相互转换，都会自动提升为int类型
char表示的ASCII表的字符

赋值运算符 +=: 内含强制转换
short s = 2;s += 3;等价于 s = (short)(s+3);
&&：短路与：如果左边为false，右边不执行

位运算符---就是对每位二进制进行运算
规律:a ^ b ^ b = a
发现小技巧，可以去菜鸟教程java板块验证结果，简单方便
举例:int a = 100; int b = a>50?200:100;
int b = ((a>50)?200:100);//b=200

switch语句

一般用于几个常量的判断,并且对于几个常量的判断switch的效率高于if

1、Switch表示这里使用的是switch语句，后面跟的是选项

表达式类型：byte,short,int,char

JDK5以后可以是枚举，Jdk7以后可以是字符串

switch语句什么时候结束?

遇到break或者执行到switch语句的末尾

基本类型：形式参数的改变对实际参数没有影响（传递的是值，存放在内存中，函数方法结束，内存释放）

引用类型：形式参数的改变直接影响实际参数(传递的是地址)

但是，字符串是特殊的引用类型，实参传递到形参时，实际上是把值传递给了形参(此时没有传递地址，s还是指向原来的地址)

public static void main(String[] args) {
               String s = "abc";
               change(s);
               System.out.println(s);//abc
          }
          public static void change(String s) {
               s += "hello";
          }

堆，栈，方法区

在静态方法中是没有this关键字,因为静态是随着类的加载而加载。而this是对象创建才存在的

接口特点：

成员变量：只能是常量。默认修饰符：public static final

成员方法：只能是抽象方法。默认修饰符：public abstract

==和equals()的区别?
          ==:
               比较基本类型：比较的是基本类型的值是否相同。
               比较引用类型：比较的是引用类型的地址值是否相同。
          equals():
               比较引用类型，默认比较的是引用类型的值是否相同。
               如果类重写了该方法，那就得按照重写后的规则进行比较。

: ""和null的区别

最本质的区别是否在内存中开辟内存空间，"'会开辟内存空间，而null不会，在开发的时候要养成良好的习惯用null

冒泡排序

就是大的气泡往后面冒。

public static void bubbleSort(int[] arr) {

              // 外循环控制比较的次数

              for (int i = 0; i < arr.length - 1; i++) {

                     // 内循环控制每次比较中，元素两两比较的过程。每次需要比较的数据是逐渐减少的。

                     for (int j = 0; j < arr.length - 1 - i; j++) {

                            // 比较相邻元素，如果前面的大，进行交换

                            if (arr[j] > arr[j + 1]) {

                                   int temp = arr[j];

                                   arr[j] = arr[j + 1];

                                   arr[j + 1] = temp;

                            }

                     }

              }

       }

3、String和StringBuffer区别

1、String一旦被创建就不能被修改，但是StringBuffer可以被修改

2、StringBuffer采用的是缓冲区机制，随着数据的增多，还会继续开辟内存空间

基本类型的包装类

基本类型的数据我们只能使用值，不能做更多的操作。为了方便我们操作，java就把每种基本类型进行了包装。

int--Integer

char--Character

5、JDK5以后的新特性

1、自动装箱：基本类型赋值给引用类型 Integer integer = 1;

2、自动拆箱：引用类型赋值给基本类型 int i = new Integer(2);

String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6);//true
s5指向字符串常量池"hello"的地址,s6指向已经存在的"hello"的地址

Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);  // false
System.out.println(i5.equals(i6)); // true   

Integer i7 = 127;
Integer i8 = 127;
System.out.println(i7 == i8); // true
System.out.println(i7.equals(i8)); // true

结论：byte范围内的值（-128 ~ 127），java提供了一个常量池。直接赋值给Integer，是从常量池里面获取的。

SimpleDateFormat类

常用的一个：yyyy-MM-dd HH:mm:ss:SSS

Calendar类

Calendar calendar = Calendar.getInstance();

1.获取月份 Calendar.MONTH + 1 (Calendar.MONTH的值的范围是0-11,需要+1变成对应的月份）

int month = calendar.MONTH+1;

2.获取星期

有些地区以星期日作为一周的第一天

//外国人的1是中国的7

//外国人的2-7是中国的周1-6

int week =  calendar.get(Calendar.DAY_OF_WEEK)==1?7: calendar.get(Calendar.DAY_OF_WEEK)-1;

迭代器

ConcurrentModificationException：在迭代的时候给集合增加元素，删除元素(注意：不是通过索引删除)造成的

并发修改异常：

public class Test {
    public static void main(String[] args)  {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(2);
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            Integer integer = iterator.next();
            if(integer==2)
                list.remove(integer);
        }
    }
}

在单线程环境下的解决办法

使用迭代器iterator的remove方法

public class Test {
    public static void main(String[] args)  {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(2);
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            Integer integer = iterator.next();
            if(integer==2)
                iterator.remove();   //注意这个地方
        }
    }
}

多线程解决方案

List<string> myList = new CopyOnWriteArrayList<string>();
 myList.add( "1");
 myList.add( "2");
 myList.add( "3");
 myList.add( "4");
 myList.add( "5");
 
new Thread(new Runnable() {
   
     @Override
     public void run() {
          for (String string : myList) {
               System.out.println("遍历集合 value = " + string);
             
               try {
                    Thread.sleep(100);
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
          }
     }
}).start();
 
new Thread(new Runnable() {
   
     @Override
     public void run() {
        
          for (int i = 0; i < myList.size(); i++) {
               String value = myList.get(i);
             
               System.out.println("删除元素 value = " + value);
         
           if (value.equals( "3")) {
                myList.remove(value);
                i--; // 注意                           
           }
         
           try {
                    Thread.sleep(100);
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
          }
     }
}).start();

参考：https://www.cnblogs.com/dolphin0520/p/3933551.html

for高级循环

是集合中（Collection）迭代器的简写形式

for(数组或 Collection子类的元素类型变量名：数组或 Collection子类)

{ //使用变量 }

 for(Object obj : list){

                    System.out.println(obj);

}

List接口的三个子类的

查询多用ArrayList（数组）,增删多用LinkedList（链表）,Vector和ArrayList功能相同，线程安全，效率低

HashSet类中的add（obj）方法如何保证元素的唯一性

重写hashCode()和equals()方法

TreeSet如何保证元素唯一性

内部采用的是二叉树结构，相同的元素就不操作

2如何判断两个元素是否相同

A、对象所属的类去实现Comparable接口
重写compareTo方法
如果该方法返回0 ，则两个元素相同

public class Person implements Comparable{
               @Override
               public int compareTo(Object o) {
                    return 0;
               }
}
TreeSet set = new TreeSet();
set.add(new Person());

B、调用TreeSet的带参构造方法，传入Comparator的子类对象
该子类对象重写compare(T o1, T o2)方法
如果返回0则两个元素相同

public class MyComparator implements Comparator {
     @Override
     public int compare(Object o1, Object o2) {
          return 0;
     }
}

TreeSet set = new TreeSet(new MyComparator());
set.add(new Student);

。。。