Java基础(局部内部类,常用类,集合,插入排序)

1.局部内部类

1.书写位置:在外部类的成员方法中的定义的类

局部内部类可以访问外部类的成员变量包括私有

在外部类的局部位置,访问内部类的成员方法,创建当前局部内部类对象来访问

2.局部内部类访问局部变量的时候,此时局部变量应该注意什么?为什么要加入final关键字呢?

原因:

​ 局部变量的生命周期是随着方法调用而存在,随着方法调用结束而消失

​ 而当前外部类对象调用method 方法的时候,此时num进入栈内存,在局部位置创建了局部内部类对象

​ 而局部内部类对象调用它的成员方法访问该变量,方法method方法结束之后,内部类对象不会立即消失,

​ 它里面的成员方法在访问局部变量,局部变量必须变成常量,常驻内存,否则如果当前变量消失了,局部内部类 的成员依然在访问就会出现冲突!

//外部类
class Outer2{
    public void method(){
        int num = 20 ; //局部变量

                class Inner2{
                    public void show(){
                        System.out.println(num);
                    }
                }
                    //创建Inner2类对象
                        Inner2 inner2 = new Inner2() ;
                        inner2.show();
                    }
                }
//测试类
public class OuterDemo2 {
    public static void main(String[] args) {
        //创建Outer2对象
        Outer2 outer2 = new Outer2() ;
        outer2.method();
    }
}

3.匿名内部类

匿名内部类是没有名字的内部类,一般在局部位置使用;

格式:匿名内部类是内部类的一种简化格式

​ new 类名(可以是抽象类,也可以是具体类)或者接口名(){

​ 重写功能;

}

匿名内部类的本质:

​ 继承了该类或者是实现了该接口的子类对象

2.Object类

java.lang.Object:是类结构层次的根类(超类—>父类),所有的类都默认继承自Object子类(派生类)

1.获取一个类的字节码文件对象的方式:

1)通过Object类的getClass() 得到正在运行的java类: class 包名.类名;

2)任意的Java类型的class属性 获取当前类的字节码文件对象Class;

3)Class里面的foeName方法(“类的全限定名称(包名.类名)”)

2.Object类的public String tostring()方法

建议所有的子类都覆盖此方法

返回对象的字符串表示形式.结果应该是一个简明扼要的表达;

大部分的常用类或者集合都会重写Object类的toString(0方法

3.Object类的equals方法

public boolean equals(Object obj) 判断当前obj对象是否和当前对象相等;

4.equals和==的区别?

==: 连接的基本数据类型比较的是数据值是否相同;

==: 连接的是引用数据类型,比较的是地址值是否相同;

equals方法::如果使用Object默认的:底层用==,默认比较的还是两个对象的地址值是否相同,

​ Student s1 = new Student(“文章”,35) ;

​ Student s2 = new Student(“文章”,35) ;

s1和s2虽然地址值不同,他们的成员的内容相同,认为他是同一个人,但是如何让s1.equals(s2)为true:针对equals来说

比较的是成员信息内容是否相同;

​ 重写Object的equals方法同时还需要重写hashCode

​ 内容相同,还需要比较哈希码值相同

​ alt+ins—>hashcode+equals方法

​ 重写之后,就比较的是成员信息的内容是否相同!

5.Object类的clone方法

protected Object clone() throws CloneNotSupportedException:创建对象并返回该对象的副本

这个方法会抛出一个异常,throws:表示的是可能出现异常,针对调用者必须进行处理

要使用clone方法,当前某个对象所在的类必须实现"标记接口"Cloneable(没有字段(成员变量),也没有成员方法)

实现这个接口,那么就可以使用Object的clone()方法

要进行克隆必须实现标记接口Cloneable

public class ObjectDemo {
    public static void main(String[] args) throws CloneNotSupportedException{
        //创建学生对象
        Student s1 = new Student("高圆圆",42) ;
        System.out.println(s1);
        System.out.println(s1.getName()+"---"+s1.getAge());

        System.out.println("-----------------------------------");
        //调用克隆方法clone()
        Object obj = s1.clone(); //已经克隆了(浅克隆:将s1地址值赋值给Objet)
        //向下转型
        Student s2 = (Student) obj;
        System.out.println(s2);
        System.out.println(s2.getName()+"---"+s2.getAge());

        System.out.println("-----------------------------------");

        //传统方式
        Student s3 = s1 ;
        System.out.println(s3.getName()+"---"+s3.getAge());


    }
}

3.String类

String s = “” ;// 空字符串 ,存在String对象 “”

String s = null ; 空值 (空对象) null:引用类型的默认值

1.java.lang.String:代表的字符串:
 字符串是一个常量,一旦被赋值了,其值(地址值)不能被更改;
 推荐使用方式:
 		String  变量名 = "xxxx" ;//xxxx代表 的当前String的实例

2.数组中有没有length方法,String类中有没有length方法,集合中有没有length方法

int length():		获取字符串的长度

数组中没有length()方法,是length属性;
String类中有length()方法;
集合中没有length()方法;在集合中是size()方法

构造方法:
		public String():空参构造:空字符序列;
		public String(byte[] bytes):将一个字节数组构造成已和字符串,使用平台默认的字符集;
		public String(byte[] bytes,字符集):使用指定的字符集,将字节数组构造成一个字符串;
		public String(byte[] bytes,int offset,int length):将指定的部分字节数组转换成字符串;
		参数1:字节数组对象,参数2:指定的角标值  参数3:指定长度;
		public String(char[] value):将字符数组构造成一字符串;
		public String(char[] value,int offset,int count):将部分字符数组转换成字符串;
		 public String(String original):构造一个字符串,参数为字符串常量;

 String s1 = "hello" ;
 String s2 = new String("hello") ;
 在内存中分别创建了几个对象?
 第一个创建了一个对象,直接在常量池创建,开辟常量池空间
 第二个:创建了两个对象,一个堆内存中开辟空间,一个指向常量池
 一般使用第一种定义格式

3.String类的equals方法

	String类型重写了Object的equals方法
	判断两个两个字符串的内容是否相同

4.String类的常用转换功能

	byte[] getBytes()  :将字符串转换成字节数组 (编码);
	public char[] toCharArray():将字符串转换成字符数组;
	public String toString():返回自己本身---"当前字符串的内容";
	 public String toUpperCase():将字符串转换成大写;
	 public String toLowerCase():将字符串转换成小写;

5.String类的常用判断功能

	public boolean equals(Object anObject):比较两个字符的内容是否相同 (区分大小写);
	public boolean equalsIgnoreCase(String anotherString):比较两个字符串是否相同(不区分大小写);
	public boolean startsWith(String prefix):判断字符串是否以指定的内容开头;
	public boolean endsWith(String suffix):判断字符串是否以指定的内容结尾;
	boolean isEmpty()  判断字符串是否为空 :若为空,则返回true;否则返回false;

例:已知一个用户名和密码,然后键盘录入用户名和密码,给三次机会,如果用户名和密码一直,提示 "登录成功",如果机会用完了, 换一种 提示"账号被锁定,请联系管理员",如果没有用完,提示"您还剩xxx"次机会
public class StringTest {
    public static void main(String[] args) {
        // 1)给定用户名和密码
        String username = "admin" ;
        String password = "admin" ;

        //2)循环3次机会
        for(int x = 0 ; x < 3 ;x ++){
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in) ;
            //提示并录入数据
            System.out.println("请您输入用户名:");
            String name = sc.nextLine() ;
            System.out.println("请您输入密码:");
            String pwd =sc.nextLine() ;

            if(username.equals(name) &&  password.equals(pwd)){
                System.out.println("登录成功");
                break ; //结束
            }
            //当机会用完了
            if((2-x)==0){
                System.out.println("对不起,您的账号被锁定,请联系管理员");
            }else{
                System.out.println("您还剩下"+(2-x)+"次机会");
            }
        }
    }
}

6.String类中的获取功能:

	int length():获取字符串长度;
	public char charAt(int index);获取指定索引处的字符;
	public String concat(String str):将指定的字符串和当前字符串进行拼接,获取一个新的字符串;
	public int indexOf(int ch):返回指定字符第一次出现的索引值;
	public int lastIndexOf(int ch):返回值指定字符最后一次出现的索引值;
	public String[] split(String regex): 拆分功能:通过指定的格式将字符串---拆分字符串数组;
	public String substring(int beginIndex) :从指定位置开始默认截取到末尾角标从0开始;
	public String substring(int beginIndex,int endIndex) 从指定位置开始,截取到位置结束(包前不包右) 只能取到endIndex-1处;
	public static String valueOf(boolean/int/long/float/double/char...Object b) 万能方法,将任意类型转换String类型

7.字符串的其他功能

	public String replace(char target,char replacement):替换功能 将指定的内容使用target字符进行替换;
	public String replaceAll(String regex, String replacement) :将指定的和参数1正则表达式匹配的字符串 使用replacement进行替换;
	public String trim():去除字符串两端的空格;
	public int compareTo(String anotherString):按照字典顺序比较,返回值是int;

8.String类的遍历

	可以使用String类的获取功能:charAt(int index) ---->char;
	利用String类的length():获取字符串长度 + charAt(int index);
	定义一个将数组转换成String的功能,返回值就是String
	拼接:+:拼接符号concat():拼接功能

//例:键盘录入一个字符串:判断字符串是否为对称字符串:
public class StringTest4 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请您输入一个字符串:");
        String line = sc.nextLine() ;
        
        //调用功能
        boolean flag = compare(line) ;
        System.out.println(flag);

        System.out.println("--------------------------------");

        //方式2:使用StringBuffer的功能改进
        boolean flag2 = compare2(line) ;
        System.out.println(flag2);
    }

    private static boolean compare2(String line) {
       /* //将line--->StringBuffer
        StringBuffer sb = new StringBuffer(line) ;
        String str = sb.reverse().toString();
        return str.equals(line) ;*/

       return new StringBuffer(line).reverse().toString().equals(line) ;
    }


    //比较的功能
    private static boolean compare(String line) {


        //创建一个新的字符数组,动态初始化
        char[] charArray = new char[line.length()] ;

        //遍历line字符串,通过charAt(int index)获取每一个字符
        for(int x = 0 ; x < line.length() ; x ++){
           charArray[x] = line.charAt(x) ;//将字符赋值字符数组中的每一个元素
        }

        //遍历字符数组charArray,保证长度/2
        for(int i = 0 ; i < charArray.length/2 ; i ++){
            //判断 i=0  charArray[0]  charArray[arr.length-1-0]
            //i= 1  charArray[1]  charArray[arr.length-1-1]
            if(charArray[i] !=charArray[charArray.length-1-i]) {
                return false;
            }
        }
        return true ;
    }
}

4.Integer

Integer:int类型的包装类类型(引用类型),包含了int类型的原始数据值

需要基本类型和String类型之间转换:需要中间桥梁(基本类型对应的包装类类型)

整数类型 引用类型(默认值都是null)

byte Byte

short Short

int Integer

long Long

浮点类型

float Float

double Double

字符类型

char Character

布尔类型

boolean Boolean

Integer的使用:
	进制的转换----就可以使用Integer静态功能		通过Integer得到int类型的取值范围
	public static String toBinaryString(int i):将整数---->二进制 的字符串;
	public static String toOctalString(int i):将整数---->八进制的字符串;
	public static String toHexString(int i):将整数---->十六进制数据;
	public static final int MAX_VALUE:int的最大值;
	public static final int MIN_VALUE:int的最小值;

2.Integer的构造方法:

	Integer(int value):可以将int类型保证为Integer类型;
	Integer(String s) throws NumberForamtException:  抛出一个数字格式化异常;
	注意事项:当前字符串如果不是能够解析的整数,就会出现数字格式化异常,s必须为 数字字符串

5.日历类(Calendar)

1.日历类:java.util.Calendar
Calendar:提供一些诸如 获取年,月,月中的日期 等等字段值
日历类是一个抽象类,不能实例化;
	静态功能:返回值是他本身	public static Calendar getInstance()
成员方法:
	public int get(int field):根据给定日历字段----获取日历字段的值(系统的日历);
	public abstract void add(int field,int amount):给指定的日历字段,添加或者减去时间偏移量
	field : 日历字段, amount : 偏移量

public class CalendarDemo {
    public static void main(String[] args) {
        //创建日历类对象
        //获取系统的年月日
        Calendar calendar = Calendar.getInstance();
       // System.out.println(calendar);
        
        //获取年
        int year = calendar.get(Calendar.YEAR) ;

        //获取月:
        int month = calendar.get(Calendar.MONTH) ;

        //获取月中的日期
        int date = calendar.get(Calendar.DATE) ;

        System.out.println("当前日历为:"+year+"年"+(month+1)+"月"+date+"日");

        System.out.println("------------------------------------------------");
        //获取3年前的今天
        //给year设置偏移量
        calendar.add(Calendar.YEAR,-3);
        //获取
        year = calendar.get(Calendar.YEAR) ;
        System.out.println("当前日历为:"+year+"年"+(month+1)+"月"+date+"日");
    }
}

2.java.util.Date:表示特定瞬间,精确到毫秒!
	允许格式化和解析日期字符串;
构造方法:
	public Date():当前系统时间格式;
	public Date(long date):参数为 时间毫秒值---->Date对象 

public class DateDemo {
    public static void main(String[] args) {
        //创建日期类对象
        Date date  = new Date() ;
        System.out.println(date);
        //Wed Jul 28 17:32:06 CST 2021 日期对象
        System.out.println("------------------------");

        long time = 60*60 ;
        Date date2 = new Date(time) ;
        System.out.println(date2);
    }
}

3.日期格式转换为String
	DateForamt:抽象类----提供具体的日期/格式化的子类:SimpleDateFormat
	format(Date对象)--->String
	SimpleDateFormat:构造函数
	public SimpleDateFormat(String pattern):使用指定的模式进行解析或者格式
	
	 参数:
               一种模式
               表示年           	"yyyy"
               表示月         	    "MM"
               表示月中的日期   	 "dd"
               一天中小时数      	  "HH"
               分钟数              "mm"
               秒数                "ss"

String:日期文本---->Date
	解析过程:
	public Date parse(String source)throws ParseException
	如果解析的字符串的格式和public SimpleDateFormat(String patter)的参数模式不匹配的话,就会出现解析异常!
	封装工具类DateUtils :构造方法私有,功能都是静态

6.StringBuffer,StringBuilder与数组

1.StringBuffer和StringBuilder的区别:
共同点:
	两个都是字符串缓冲区,支持可变的字符序列;
不同点:
	StringBuffer:线程安全的类---->同步的,执行效率低;
	StringBuilder:线程不安全的类---->不同步----->执行效率高 ;
	

2.StringBuffer和数组的区别:
共同点:
	都是容器,都可以存储任意类型的元素 ,	可以存储基本类型,也可以存储引用类型;
不同点:
	数组的长度是固定的;
	StringBuffer的长度是可变的

7.StringBuffer,String的转换与int,String的转换

1.StringBuffer和String转换
    //String--->StringBuffer
    String s = "hello" ;
    //使用StringBuffer的有参构造方法
    StringBuffer sb = new StringBuffer(s)
    //或者是StringBuffer的追加功能
    StringBuffer sb = new StringBuffer() ;
    sb.append(s) ;

    //StringBuffer--->String
    //String类的构造方法 String(StringBuffer)
    StringBuffer buffe = new StringBuffer("world") ;
    String str = new String(buffer) ;
    //第二种方式:StringBuffer的toString方法

2.int和String类型之间的转换
    //int---->String
   //integer类型的静态功能toString
   public static String toString(int i)
       
 //String--->int
  //Integer的静态功能
       public static int parseInt(String s)
       
  //String ---->Integer ---->int
       String s = "100" ;
	  Integer i = new Integer(s) ;
      int num = i.intValue() ;

8.Math类与Random类

Math类的常用方法:
	public static int abs(int  a):绝对值方法
	public static double ceil(double a):向上取整
	public static double floor(double a):向下取整
	public static int max(int a,int b):获取最大值
	public static int min(int a,int b):获取最小值
	public static double pow(double a,double b):a的b次幂
	public static double random():[0.0,1.0):随机数
	public static long round(double a):四舍五入
	public static double sqrt(double a):开平方根
	
Math中的功能都是静态的,里面构造方法都是私有化的

Random类:伪随机数生成器;
构造方法:	
	public Random(): 产生一个随机生成器对象,通过成员方法随机数每次没不一样的;
	public Random(long seed) :参数为long类型的值(随机数流:种子),每次通过成员方法获取随机数产生的随机数相同的;
获取随机数的成员方法:
	public int nextInt():获取的值的范围是int类型的取值范围(-2的31次方到2的31次方-1);
	public int nextInt(int n):获取的0-n之间的数据 (不包含n);

9.泛型

jdk5以后的新特性:泛型<E/T>
泛型的格式:
	<引用数据类型>;
在数组创建的时候就已经明确了集合中存储的数据类型;
泛型的好处:
	1)将运行时期的异常提前到了编译时期;
	2)避免了强制类型转换;
	3)提高了程序安全性;

10.集合

1.集合和数组的区别:
	1)长度区别:
			数组的长度是固定的;
			集合的长度是可变的;
	2)存储数据类型的区别:
			数组:可以存储基本数据类型,也可以存储引用数据类型;
			集合:只能存储引用数据类型;
	3)存储元素的区别:
			数组:存储的元素必须为同一种数据类型;
			集合:如果没有加入泛型就可以存储任意数据类型(必须是引用数据类型);

2.Collection:集合层次的根接口,一些集合允许元素重复(List),一些集合不允许元素重复(Set),一些集合有序(存储和取出一致)(List),一些集合无序(Set)

3.Collection的基本功能:
	添加:boolean add(Object e):添加元素  E(Element);
	删除:void clear() 暴力删除(将集合的素有元素全部干掉);
		boolean remove(Object o):从集合中删除指定的元素;
	获取集合的元素数: int size();
	判断功能:boolean isEmpty():判断集合是否为空,为空元素,则返回true;
			boolean contains(Object o):判断集合中是否包含指定元素,包含则返回true;
高级功能:
	boolean addAll(Collection c):添加一个集合中的所有元素;
	boolean containsAll(Collection c):包含一个集合中的所有元素;
	boolean removeAll(Collection c):删除集合中的所有元素, (删除一个算删除,还是删除所有);
	boolean retainAll(Collection c):A集合对B集合求交集;交集的元素存储在A集合中,返回值的意思是:看A集合的元素是否有变化(A集合之前的元素和取交集之后的元素进行对比),如果有变化,返回true,没有变化,返回false;
Collection最基本的遍历功能:
	Object[] toArray():将集合转换成了对象数组

4.迭代器

迭代器是集合专有的遍历方式

Iterator iterator():返回值类型接口类型,需要返回的子实现类对象;

Iterator接口:

​ boolean hasNext(): 判断迭代器中是否存在下一个元素;

​ Object next(): 获取下一个可以遍历的元素

/*例:使用Collection存储4个学生对象,然后使用Iterator iterator()迭代器遍历Collection集合中的元素,获取4个学生的信息*/
public class CollectionTest {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();

        //创建4个学生
        Student s1 = new Student("诸葛亮",45) ;
        Student s2 = new Student("庞统",30) ;
        Student s3 = new Student("周瑜",35) ;
        Student s4 = new Student("吕布",25) ;

        c.add(s1) ;
        c.add(s2) ;
        c.add(s3) ;
        c.add(s4) ;

        //获取迭代器
        Iterator iterator = c.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            Student s = (Student)obj ;
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

5.List集合

List接口继承Collection
List集合的特点:
	1)有序(存储元素和取出元素一致);
	2)允许元素重复;
具备Collection相关的功能:
	Object [] toArray();
	Iterator iterator();
	
List集合的特有功能:
	void add(int index,Object element):在指定的索引处插入元素;
	Object get(int index):获取指定位置处的元素  + int size():一种新的集合遍历方式;
	Object remove(int index):删除指定位置处的元素;
	Object set(int index,E element):修改指定位置处的元素(替换);
	
	
ListIterator<E> listIterator():列表迭代器
ListIterator接口:
	void add(E e) 添加功能;
	remove() : 删除功能

List集合如何去重?

//方式一:
public class ListTest2 {
    public static void main(String[] args) {

        //创建List集合
        List<String> list = new ArrayList<>() ;

        //现在给集合中添加重复的字符串数据
        list.add("hello") ;
        list.add("hello") ;
        list.add("world") ;
        list.add("world") ;
        list.add("javaEE") ;
        list.add("world") ;
        list.add("javaEE") ;
        list.add("android") ;
        list.add("android") ;
        list.add("ios") ;

        //新建一个空的集合List
        List<String> newList = new ArrayList<>() ;
        //遍历以前的集合
        for(String s :list){
            //使用新集合判断,不包含这个元素,说明该元素没有重复,就可以添加
            if(!newList.contains(s)){
                newList.add(s) ;
            }
        }
        //遍历新的集合
        for(String s:newList){
            System.out.println(s);
        }
    }
}

//方式二:利用选择排序的思想去完成
public class ListTest3 {
    public static void main(String[] args) {
        //创建List集合
        List<String> list = new ArrayList<>() ;

        //现在给集合中添加重复的字符串数据
        list.add("hello") ;
        list.add("hello") ;
        list.add("world") ;
        list.add("world") ;
        list.add("javaEE") ;
        list.add("world") ;
        list.add("javaEE") ;
        list.add("android") ;
        list.add("android") ;
        list.add("ios") ;

        //利用选择排序的思想完成
        for(int x = 0 ; x < list.size()-1 ; x ++){
            for(int y = x +1 ; y < list.size() ; y++){
                //如果后面的元素和前面的元素相同
                if(list.get(y).equals(list.get(x))){
                    //通过集合remove掉
                    list.remove(y) ; // public Object remove(int index)
                    //角标--
                    y -- ;
                }
            }
        }

        for(String s:list){
            System.out.println(s);
        }
    }
}

public class ListDemo {

    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<String >();

        //添加元素
        list.add("hello") ;
        list.add("hello") ;
        list.add("world") ;
        list.add("world") ;
        list.add("world") ;
        list.add("javaEE") ;
        list.add("javaEE") ;

        // void add(int index,Object element):在指定的索引处插 入元素

        list.add(1,"李白");
        //Object get(int index):获取指定位置处的元素 :返回的被获取到的元素内容
        System.out.println(list.get(1));

        //  Object remove(int index):删除指定位置处的元素,返回被删除的元素
        System.out.println(list.remove(2));
        System.out.println("---------------------------------------");

        //Object set(int index,E element):修改指定位置处的元素(替换)
        System.out.println(list.set(1,"张飞"));
        System.out.println(list);
    }
}

List集合的遍历方式:
	Object [] toArray();
	Iterator iterator();
	Object get(int index): 获取指定位置处的元素;
	Object get(int index) + int size()  :  是一种新的集合遍历方式

//产生1-30随机数 将偶数添加到List集合中
public class ListTest {
    public static void main(String[] args) {
		//创建集合
        List<Integer> list = new ArrayList<>();
        //创建随机数生成器
        Random random = new Random();
        while (true){
            int num = (random.nextInt(30)+1);
            if (num%2 == 0){
                //判断集合中是否已经存在新的随机数
                if (list.contains(num)){
                    continue;
                }else {
                    list.add(num);
                    //System.out.println(num);
                }
                //判断集合的长度
                if (list.size() == 15){
                    break;
                }
            }
        }
        //遍历集合
        for(Integer i : list){
            System.out.println(i);
        }
    }
}

6.并发修改异常

集合在使用迭代器时会经常出现的问题: 并发修改异常;
异常原因:
	当集合的元素正在被迭代器进行遍历,那么集合的对象是不能对元素进行修改增加或者删除的;
	否则就会出现并发修改异常;
根本原因:
	一个线程正在遍历,一个线程正在修改元素
		
解决方案:
	1)要么迭代器去遍历元素,迭代器去添加元素;(只有列表迭代器才具备添加的功能) 
	2)使用集合遍历,集合添加元素;

7.增强for循环

JDK5以后 提供了增强for循环,替代集合中的迭代器去遍历集合(优先在集合中使用)
格式:
	for(存储的引用数据类型 变量名 : 集合/数组对象){
		使用变量名;
	}
注意事项:当前集合对象不能为null : 否则会出现空指针异常;
foreach语句:本身就是替代迭代器,本质和迭代器相同;

public class ForeachDemo {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>() ;
        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;
        for(String s:list){
               System.out.println(s+"---"+s.length());
        }
    }
}

8.Vector集合

Vector集合特有功能:
	添加:public void addElement(Object obj):在vector对象的末尾添加元素;
	删除:public boolean removeElement(Object obj):删除元素;
	获取:public Object elementAt(int index):获取指定位置的元素;
	遍历:public Enumeration<E> elements() :Vector集合的专有遍历方式;类似于迭代器
	boolean hasMoreElements():判断是否有更多的元素可以迭代

public class VectorDemo {
    public static void main(String[] args) {

        //创建Vector集合对象
        Vector<String> v = new Vector<>() ;

        v.addElement("hello");
        v.addElement("world");
        v.addElement("SpringBoot");
        v.addElement("SpringCloud") ;

        //遍历:特有功能
        Enumeration<String> en = v.elements(); //相当于Iterator
        while(en.hasMoreElements()){
            String s = en.nextElement();
            System.out.println(s+"---"+s.length());
        }

        System.out.println("----------------------------------");
        for(String s: v){
            System.out.println(s+"----"+s.length());
        }

    }
}

11.List集合三个子实现类的特点

1.ArrayList
        底层数据结构是数组,查询快,增删慢
        通过arr[索引值]:查询到某个元素

        存储null元素---->

        线程角度:   线程不安全的类,实现不同步的  ----->执行效率高
        特点:扩容机制:1.5倍的方式扩容
        Integer[] arr = {11,22,33,44,55} ;
        添加和删除元素:需要判断
                在33这个元素后面新的元素,需要新建数组,长度是以前数组长度+1
                判断加入的元素是否33元素
                33以前,按照以前的元素在新的数组进行存储
                33,继续存储
                33以后的,加入88元素(给33以后的元素后面插入新的元素)

        public ArrayList():无参构造方法:默认容量是10
2.Vector集合:

        底层数据结构是数组,查询快,增删慢
        线程角度:线程安全的类----同步的方法---->执行效率低

        单线程程序中.考虑集合默认都会使用 ArrayList,多线程环境集合---->Vector集合
3.LinkedList
        底层数据结构是链表,查询慢,增删快
        线程角度:线程不安全的类---->不同步---->执行效率高

                特有功能:
                            addFirst()
                            removeFirst()
                            getFirst()

                            xxxLast()
        应用场景:模拟栈结构特点:
                   先进后出
                   
如果没有明确要求使用什么(List)集合的时候 ,默认都是用ArrayList

12.插入排序

核心思想:

​ 使用1角标对应的元素进行和0角标比较,如果前面元素大,向右移动,确定角标1对应的元素的位置,再次使用2角标对应的元素依次和1和0都元素比较

public class InsertSortTest {

    public static void main(String[] args) {

        //定义一个Integer数组: Integer实现的自然排序:元素能够按照升序默认排序
        Integer[] arr = {34,8,64,51,32,21} ;

        System.out.println("排序前:");
        printArr(arr);

        //定义一个功能
        insertSort(arr) ;
        System.out.println("排序后:");
        printArr(arr);

    }
    //插入排序
    private static void insertSort(Integer[] arr) {

        //定义一个变量j
            int j ; //j记录当前角标的变化
            //定义变量 : p:表示一个比较次数
            for(int p = 1 ; p < arr.length ; p ++ ){ //比较次数    
                //定义临时变量temp
                Integer temp = arr[p] ; 
                //开始比较
                for(j = p ; j>0 && temp.compareTo(arr[j-1])<0; j-- ){ 
                    //数据移动
                    arr[j] = arr[j-1] ;
                }

                //确定temp的位置
                arr[j] = temp ;         

        }

    }

    public static void printArr(Integer[] arr){
        System.out.print("[");
        for(int x = 0 ; x < arr.length ; x ++){
            if(x == arr.length -1){
                System.out.println(arr[x] +"]");
            }else{
                System.out.print(arr[x]+", ");
            }
        }
    }
}