复习：面向对象，常用类，集合

面向对象编程（OOP）

1. 基本概念：

   • 类和对象：

     • 类：是一种用户定义的数据类型，它的定义包括属性（字段、成员变量）和方法（成员函数）。例如：

       public class Person {
           private String name;
           private int age;
       
           public Person(String name, int age) {
               this.name = name;
               this.age = age;
           }
       
           public void introduce() {
               System.out.println("Hi, my name is " + name);
           }
       }
       

     • 对象：是类的实例。通过 new 关键字创建。例如：

       Person person = new Person("John", 25);
       person.introduce();
       

   • 封装：

     • 将类的属性设为私有（private），并提供公共的（public）方法访问这些属性。例如：

       public class Person {
           private String name;
           private int age;
       
           public String getName() {
               return name;
           }
       
           public void setName(String name) {
               this.name = name;
           }
       
           public int getAge() {
               return age;
           }
       
           public void setAge(int age) {
               this.age = age;
           }
       }
       

   • 继承：

     • 通过 extends 关键字实现，子类继承父类的属性和方法。例如：

       public class Employee extends Person {
           private int employeeId;
       
           public Employee(String name, int age, int employeeId) {
               super(name, age);
               this.employeeId = employeeId;
           }
       
           public void work() {
               System.out.println("Employee is working");
           }
       }
       

   • 多态：

     • 方法重载：同一类中同名方法根据参数不同实现不同功能。

       public class MathUtils {
           public int add(int a, int b) {
               return a + b;
           }
       
           public double add(double a, double b) {
               return a + b;
           }
       }
       

     • 方法重写：子类重写父类的方法，提供新的实现。

       public class Animal {
           public void makeSound() {
               System.out.println("Animal sound");
           }
       }
       
       public class Dog extends Animal {
           @Override
           public void makeSound() {
               System.out.println("Bark");
           }
       }
       

2. 重要特性：

   • 抽象：

     • 抽象类：使用 abstract 关键字，不能实例化，可以包含抽象方法和具体方法。

       public abstract class Shape {
           abstract void draw();
       }
       
       public class Circle extends Shape {
           @Override
           void draw() {
               System.out.println("Drawing Circle");
           }
       }
       

     • 接口：使用 interface 关键字，定义一组方法，但不提供实现。

       public interface Drawable {
           void draw();
       }
       
       public class Rectangle implements Drawable {
           @Override
           public void draw() {
               System.out.println("Drawing Rectangle");
           }
       }

常用类

基本数据类型包装类

java中的基本数据类型使用八个关键字声明的，不是面向对象。

java语言是面向对象的，可以为每个基本类型定义一个类来进行表示，这样我们在类中还是保持有一个基本类型变量存储数据，同时还可以提供许多方法对变量进行操作(将十进制转化为二进制)

Integer

构造Integer对象，里面包着一个基本数据类型值，用该对象表示一个这个值

package Javaapi.Basedemo;
​
public class Integers {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        Integer a=new Integer(18);
        Integer b=new Integer("10");
        System.out.println(a);
        System.out.println(b);
       //一类为静态方法 System.out.println(Integer.toBinaryString(10));
        System.out.println(Integer.toHexString(17));
        System.out.println(Integer.toOctalString(9));
        System.out.println(Integer.max(5,9)); 
        System.out.println(Integer.compare(8,10));//可用来比较大小。返回0，1，-1，表示大小
    
    //一类是非静态
    System.out.println(a.equals(b));
    System.out.println(a.compare(b));
   //转换的方法   包装类型转换为基本类型 
    int aa=a.intValue();
    int bb=Integer.parseInt("20");
    //把基本类型转换为包装类型
    int cc=10;
    Integer dd=new Integer(cc);
    Integer ee =Integer.valueof(cc);   
        
    } 
}

自动装箱：把基本类型转为引用类型

//调用intvalue();
Integer a=new Integer(10);
Integer b=new Integer(10);
//int c.intValue();
int d=a;

自动拆箱：把引用类型转为基本类型

在valueof()方法中如果基本类型在（-128，127）之间，会从缓存的数组中直接取出一个Integer对象，减少创建次数。如果两个值相同，获取的是同一个对象。基本类型如果不在这个区间，每次都会创建一个新的Integer对象

//默认调用valueof();
int x=10;
Integer z = Integer.valueof(x);
Integer y=x;
System.out.println(y==z);
System.out.println(y.equals(z));

String类

java中所有字符串都是String类的实例

"abc"---->字符串，实际底层是一个char数组

//创建一个字符串对象
//方法一
String s1="abc";
//创建一个字符串对象时，先进行查找，如果没有相同的字符串，那就创建一个，并返回字符串和地址；如果有相同的字符串，就不用创建，直接返回已有字符串的地址

//方法二
String s2= new String("abc");
//new 每次都是在堆中创建一个新的字符串对象

StringBuffer类

因为String声明的字符串对象值一旦给定就不能改变每次创建都会创建新的字符串对象，耗时，占空间

StringBuffer是内容可以改变的字符串

char[] value; 没有使用final修饰，每次添加内容都是堆此数组进行操作，不会创建新的字符串对象

Math类

System.out.println(Math.);
System.out.println(Math.random);//返回0-1之间的一个数。可能会等于零，小于一
System.out.println(Math.floor(9.9));//向下取整
System.out.println(Math.);

Random类

Random random=new Random();
System.out.println(random.nextBoolean());
System.out.println(random.nextInt());//在int类型的取值范围内随机返回一个数
System.out.println(random.nextInt(4));//随机返回一个大于等于零，小于四范围的一个数
byte bytes= new byte[5];
random.nextByte(bytes);
System.out.println(Arrays.toString(bytes));

Date类

Date date=new Date();
System.out.println(date);

Calendar类

Calendar calendar=Calendar.getInstance();
System.out.println(calendar);

集合

单列集合:

一次放进去一个值（对象）

Collection接口，定义了单列集合公有方法

List:

可以有重复元素

ArrayList:数组列表

集合容器类中，默认可以添加Object类型，但是一般还是习惯保存同一种类型，保存多种类型，后期处理时，设计向下转换问题

泛型：可以在声明类型时自定义参数类型

LinkedList 链表列表

底层是一个链表结构，查询慢，增加，删除快

Vector：

数组列表，线程安全的

与LinkedList和ArrayList相差不多

只是内部运算不同

List接口

List集合遍历方式

1.for循环

for循环，允许修改集合元素（添加或删除）注意索引的变化与元素位置的移动

2.增强for循环

增强for循环遍历时，不允许修改集合元素（添加或删除）

3.迭代器遍历

set

不能有重复元素，是无序的，set中的元素是没有索引的

HashSet

元素是无序的，当我们向集合中添加一个元素，如果每次都使用equals()比较内容是否相等，效率会很低

如何比较：

在底层会调用hashCode()----Object中的hashCode()返回的是对象的地址(不调用这个)

会调用类中重写的hashCode()，返回的是根据内容计算的哈希值

遍历时，会用哈希值先比较是否相等，会提高比较效率，但是哈希值会存在问题，内容不同，哈希不同

此种情况下，再调用euqals()比较内容，这样设计既提高了判断效率，又安全

TreeSet

不能存储重复元素，可以根据值进行排序

底层使用了树形结构，树形结构本身就是有序的

向树形结构中添加元素时，如何判断元素大小及元素是否重复

向TreeSet中添加的元素类型必须实现Comparable接口，重写compareTo（），每次添加元素时，调用compareTo()进行元素大小判断

双列集合

键 值

Map接口

数据存储是键，值的形式存储

键不能重复的，值可以重复

通过键可以找到找到值

一个键只能映射到一个值

HashMap

键是无序的

可以存储一个建为null，值为null的元素

底层使用一个长度默认为16的数组，用来确认元素的位置，每次用key计算出哈希值，用哈希值%数组长度确定元素位置，将元素放在哈希表中指定的位置

后来继续添加元素，如果出现相同位置且不重复的元素，那么将后来的元素添加到之前的元素的next节点

当链表长度大于64时链表才会转为红黑树

哈希表负载因子为0.75，当哈希表使用数组的0.75时，会自动扩容为原来数组长度的2倍

TreeMap

键可以排序

键元素类型必须实现Comparable接口，重写compareTo()。

Hashtable

实现了同步

方法上都添加了synchronized锁

Hashtable中不能存在null的键和null的键值

Collections类

int... a:可变长度的参数,本质是一个数组，一个参数列表中只能有一个可变长度参数,必须放在参数列表的最后

package Mapdemo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;

public class Collection11 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList=new ArrayList();
        arrayList.add(1);
        arrayList.add(2);
        Collections.addAll(arrayList,3,5,4);
        //Collections.sort(arrayList);//升序排列
        Collections.sort(arrayList, new Comparator<Integer>() {
            @Override//逆序排列
            public int compare(Integer o1, Integer o2) {
                return o2.intValue()-o1.intValue();
            }
        });
        System.out.println(Collections.binarySearch(arrayList, 1));
        Collections.swap(arrayList,1,2);//交换指定位置中的元素
        ArrayList<Integer> arrayList1=new ArrayList<>();
        arrayList1.add(5);
        arrayList1.add(6);
        arrayList1.add(7);
        arrayList1.add(8);
        arrayList1.add(9);
        Collections.copy(arrayList1,arrayList);//将arrayList中的元素复制替换到arrayList1中
        Collections.fill(arrayList,2);//用指定元素替换该集合中的所有元素
        Collections.max(arrayList);//最大值
        Collections.min(arrayList);//最小值
        Collections.shuffle(arrayList);//随机排序
        Collections.reverse(arrayList);//逆序
        Collections.replaceAll(arrayList,5,4);//将指定元素替换旧的元素
        System.out.println(arrayList);
        System.out.println(arrayList1);
    }
}