javaSE

main

循环练习题

案例一：输出1-100中被5整除的数，每行输出6个

package loopprc;
public class loopdemo01 {
//输出1-100中被5整除的数，每行输出6个
public static void main(String[] args) {
    int j=0;
    for (int i = 0; i <=100; i++) {
        if (i%5==0){
            System.out.print(i+"\t");
            j++;
            if (j%6==0){
                System.out.println();
            }
        }
    }
}
}

案例二：实现一个功能：

请录入10个int类型的数字，当你输入的数是666的时候，中断程序
判断其中录入的正数的个数并输出
判断系统的推出状态：是正常的推出还是被迫退出

Scanner sc = new Scanner(System.in);
    int count = 0;
    for (int i = 1; i <= 10; i++) {
        System.out.println("请输入第一个："+i+"数字");
        int num = sc.nextInt();
        if (num==666){
            count = 1;
            break;
        }else {
            count = 2;
        }
    }
    if (count==1){
        System.out.println("被迫退出");
    }else {
        System.out.println("正常退出");
    }

案例三：输出乘法口诀

public static void  chengfa(){
    for ( int j =1; j <=9; j++) {
        for (int i = 1; i <=j; i++) {
            System.out.print(i+" * "+j+" = "+(i*j)+" ");
        }
        System.out.println();
    }
}

第二种方法：

for (int i = 9; i >0; i--){
         for ( int j =1; j <=i; j++){
            System.out.print(i+" * "+j+" = "+(i*j)+" ");
        }
        System.out.println();
    }

案例四：打印各种形状：

直角三角形：

public static void zhijiaosanjiao1(){
        for (int i = 0; i <5; i++) {
            for (int j =0; j <i; j++) {
                System.out.print(" "+"*");
            }
            System.out.println(" ");
        }
    }
    public static void zhijiaosanjiao(){
        for (int i = 0; i <5; i++) {
            for (int j =5; j >i; j--) {
                System.out.print(" "+"*");
            }
            System.out.println(" ");
        }
    }

等腰三角形：

public static void dengyaosanjiao(){
        for (int i = 0; i <5; i++) {
            for (int s =5; s >i; s--) {
                System.out.print(" ");
            }
            for (int j =0; j <=i; j++) {
                System.out.print("*"+" ");
            }
            System.out.println(" ");
        }
    }

等腰倒立三角形

public static void dengyaosanjiao2(){
        for (int i = 5; i >=0; i--) {
            for (int s =5; s >i; s--) {
                System.out.print(" ");
            }
            for (int j =0; j <=i; j++) {
                System.out.print("*"+" ");
            }
            System.out.println(" ");
        }
    }

菱形：

public static void lingxing(){
        for (int i = 0; i <5; i++) {
            for (int s =5; s >i; s--) {
                System.out.print(" ");
            }
            for (int j =0; j <=i; j++) {
                System.out.print("*"+" ");
            }
            System.out.println(" ");
        }
        for (int i = 5; i >=0; i--) {
            for (int s =5; s >i; s--) {
                System.out.print(" ");
            }
            for (int j =0; j <=i; j++) {
                System.out.print("*"+" ");
            }
            System.out.println(" ");
        }

空心菱形：

public static void lingxing(){
    for (int i = 0; i <5; i++) {
        for (int s =5; s >i; s--) {
            System.out.print(" ");
        }
        for (int j =0; j <=i; j++) {
            if (j==0||j==i){
                System.out.print(" "+"*");
            }else {
                System.out.print(" "+" ");
            }
        }
        System.out.println(" ");
    }
    for (int i = 5; i >=0; i--) {
        for (int s =5; s >i; s--) {
            System.out.print(" ");
        }
        for (int j =0; j <=i; j++) {
            if (j==0||j==i){
                System.out.print(" "+"*");
            }else {
                System.out.print(" "+" ");
            }
        }
        System.out.println(" ");
    }
}

输出空心的诀窍就是首尾输出。

数组

数组的概念：同一种类型数据的集合。其实数组就是一个容器。

运算的时候有很多数据参与运算,那么首先需要做的是什么.不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的方式，能存数据的地方我们称之为容器，容器里装的东西就是数组的元素, 数组可以装任意类型的数据，虽然可以装任意类型的数据,但是定义好的数组只能装一种元素，也就是数组一旦定义，那么里边存储的数据类型也就确定了。

好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

数组动态初始化：
声明并开辟数组：
数据类型 [] 数组名称 = new 数据类型[长度];
数据类型 [] 数组名称 = ｛数组内容给｝；

数组操作：删除

package ArraysPrc;
import java.util.Arrays;
public class deleteArrays {
    public static void main(String[] args) {
            int[] arr = {10,4,5,6,3,7,9};
            deleteArray(arr,2);
        System.out.println(Arrays.toString(arr));
    }
    public static void deleteArray(int[] arr,int i) {
            for (int j = i; j<arr.length-1; j++){
                arr[j] = arr[j+1];
            }
            arr[arr.length-1]=0;
    }
}

二维数组：

数组的普通声明：int【】 arr 定义了一个数组，名字叫arr，堆空间中的每个格子都是int 类型

double 【】arr 定义了一个数组，名字叫arr，堆空间中每个个子都是double类型

int 【】【】arr;这个是？

相当于我定义了一个数组名字叫arr 每个格子中放入的数据都是int[]数组类型，

二维数组指的就是数组里套一个数组

集合

什么是算法和数据结构

算法：

可以解决具体问题。例如：1+2+3+4+5.。。+99+100
流程=算法
有设计解决的具体的流程
算法1:（1+100）50=101 50-->高斯算法
有评价这个算法的具体指标
有评价这个算法的具体的指标-->时间复杂度，空间复杂度（从数学角度考虑）

数据结构：如何组织管理数据的结构，按照某种规则结构来组织管理我们的数据

数据结构分为：

逻辑结构：-->思想上的结构-->卧室，厨房，卫生间-->线性表（数组，链表），图，树，栈，队列
物理结构：-->真实结构-->钢筋混凝土+牛顿力学-->紧密结构（顺序结构），跳转结构（链式结构）

以线性表为例：

线性表逻辑结构表述图：

线性表的特点：

线性表是n个数据类型相同的数据元素的有限序列，通常记作：a，ai-1,ai,ai+1

1.相同的数据类型

线性表中可以有n个相同属性的元素，比如可以都是数字，可以都是字符，相同类型意味着每一个元素占用相同的内存空间。

2序列（顺序性）

ai-1,ai,ai+1为例子，ai的前一位是ai-1，ai的后一位是ai+1，一般ai0为表头，除了表头和表尾元素外，任何一个元素有且仅有一个直接前驱和一个直接后继

3有限

线性表中的数据元素定义为n，n是个有限值，当n=0的时候就是线性表为空，在非空的线性表中每个数据元素都有唯一确定的序号，下标

逻辑结构和物理结构的关系

线性表逻辑，对应真实的如果是紧密结构，典型：数组；

线性表逻辑结构，对应的真实结构如果是跳转结构，典型为链表

什么是紧密结构？

在存储数据的时候选择相邻的位置存储，

以int数组为例，int 4位，下图所示：

优点：

寻址快-->查找元素快

缺点：

删除和增加元素效率低

什么是跳转结构？

以链表为例

单向链表：

每一个元素的位置除了存放自己的数据还要存放寻找下一个元素的地址

双向链表：

每个元素除了存放自己的数据，还存放了上一个元素的地址和下一个元素的地址

循环链表：

就是首元素和尾元素互相指向，首尾相连

跳转结构：

优点：删除元素，插入元素效率高，

缺点：查询元素效率地。为什么？

应为我如果像查找一个元素我要从上一个寻找，如果多的话，十分麻烦，数组寻址找是直接寻找，效率十分之快

集合前言

数组，集合都是对多个数据进行存储操作，简称为容器

PS:这里的存储是内存层面的存储，而不是持久化存储

数组：只能存放同一种类型的数据

，长度无法更改，只能放同一种类型的数据

一旦指定了长度，那么长度就被确定，不可以更改，删除增加效率低，无法直接判断数组的实际元素的数量，需要我们自己去写，存储为有序，可重复。

如何解决数组的缺点？

用于解决数组缺点的新的存数的数据结构--->集合

什么是集合

我们有很多集合，为什么要学习这么多集合，应为不容的集合底层的数据机构不一样

将集合分为两种类型

存储方式：

一个一个数据的存储

一对一对数据的存数

colletion接口

特点：不唯一，有序

新增：add(E e)
修改：
删除：remove(Object o)，clear()
查看：iterator()，size()
判断：contains(Object o)，equals(Object o)，isEmpty()

/*
* 新增：add(E e)
* 修改：
* 删除：remove(Object o)，clear()
* 查看：iterator()，size()
* 判断：contains(Object o)，equals(Object o)，isEmpty()
* */
    public static void main(String[] args) {
        //接口不能创建对象：利用实现类创建
        Collection col = new ArrayList();
//        集合有一个特点，只能存放引用数据类型，不能是基本数据类型，
//        基本数据类型自动装箱，对应包装类
        col.add(18);
        col.add(12);
        col.add(15);
        System.out.println(col);
        List list = Arrays.asList(new Integer[]{2,1,3,4,5});
        col.addAll(list);
        System.out.println(col);
        col.clear();
        System.out.println(col);
        System.out.println("集合的数量："+col.size());
        System.out.println("集合是否为空："+col.isEmpty());
        boolean remove = col.remove(15);
        System.out.println(col);
        System.out.println("是否删除成功："+remove);
        Collection col2 = new ArrayList();
//        集合有一个特点，只能存放引用数据类型，不能是基本数据类型，
//        基本数据类型自动装箱，对应包装类
        col2.add(18);
        col2.add(12);
        col2.add(15);
        Collection col3 = new ArrayList();
//        集合有一个特点，只能存放引用数据类型，不能是基本数据类型，
//        基本数据类型自动装箱，对应包装类
        col3.add(18);
        col3.add(12);
        col3.add(15);
        System.out.println(col2.equals(col3));

集合有一个特点，只能存放引用数据类型，不能是基本数据类型，那我们为什么加入基本类型没有报错？
解：基本数据类型自动装箱，对应包装类

遍历的两种方式

增强for循环

for (Object o : col) {
            System.out.println(o);
        }

迭代器

Iterator it = col.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

迭代器简略原理：

list接口

list接口常用方法：

list接口的常用方法

增加:add(E e),
删除:clear(),remove(int index), remove(Object o)
修改：set(int index, E element)
查看：get(int index),size()
判断：

List list = new ArrayList();
        list.add(12);
        list.add(5);
        list.add(-1);
        list.add(19);
        list.add(2);
        list.add("abc");
        System.out.println(list);
        list.add(3,14);
        System.out.println(list);
        list.set(3,77);
        System.out.println(list);
        list.remove(2); //调用这个方法参数为integer的时候，调用的是参数为index的remove方法，按照喜爱表删除
        System.out.println(list);
        list.remove("abc");
        System.out.println(list);
        Object o = list.get(0);
        System.out.println(o);
        System.out.println("-----------");
//        遍历list集合，普通for循环
        for (int i = 0; i <list.size(); i++) {
            System.out.print( list.get(i));
        }
        System.out.println("\n-----------");
        for (Object o1 : list) {
            System.out.print(o1);
        }
        System.out.println("\n-----------");
       Iterator it = list.iterator();
       while (it.hasNext()){
           System.out.print(it.next());
       }
    }

以上就是常用方法外加迭代的是那种遍历方式

1.8 jdk Arraylist集合源码分析

底层数组，size是有效数据的长度，
在1.8中调用无参数构造器时底层的elementdata数组初始化为｛｝
add方法

在调用add方法后底层数组才重新赋值，为新的数组，长度为10，节省了内存，只有在需要添加的时候我们才要创建数组

Vector接口

底层是Object数组，int类型属性表示数组中的有效数据
Vector vr = new Vector();调用构造器的时候
add

list和Vector的区别

底层都是数组的扩容

区别：

ArrayList：

ArrayList底层扩容长度为缘数组的1.5倍，线程不安全，效率高

Vector：

底层扩容长度为原数组的两倍，线程安全，效率地，已经淘汰

底层都为数组：

优点：查询效率高
缺点：删除元素效率低，
特点：可重复

JavaSE 进阶-javase进阶（二）https://developer.aliyun.com/article/1469543

JavaSE 进阶-javase进阶（一）