Java基础教程--安卓入门教程（七）

Myth丶恋晨 2021-09-14 17:42 398阅读 0赞

关注我，每天都有优质技术文章推送，工作，学习累了的时候放松一下自己。

欢迎大家关注我的微信公众号：「醉翁猫咪」

![20180207231814861][]

##### 什么是接口？ #####

接口的基本语法  
  
接口的基本语法（一）  
使用interface定义  
接口当中的方法都是抽象方法；  
接口当中的方法都是public权限  
  
接口中全是抽象函数，不能生成对象  
  
interface USB\{  
 public void read();  
 public void write();  
\}  
  
class USBPhone implements USB\{  
//复写  
 public void read()\{  
  System.out.println("USBPhone read");  
 \}  
 public void write()\{  
  System.out.println("USBPhone write");  
 \}  
\}  
  
class Test\{  
 public static void main(String args\[\])\{  
  USBPhone usbPhone = new USBPhone();  
  USB usb = usbPhone;  
  usb.read();  
  usb.write();  
 \}  
\}

### 接口的基本语法（二） ###

实现接口使用implements关键字  
一个类可以实现多个接口  
一个接口可以继承多个接口  
class Phone implements USB,WiFi\{  
 public void read()\{  
  System.out.println("USB read");  
 \}  
 public void write()\{  
  System.out.println("USB write");  
 \}  
 public void open()\{  
  System.out.println("USB open");  
 \}  
 public void close()\{  
  System.out.println("USB close");  
 \}  
\}  
  
interface USB\{  
 public void read();  
 public void write();  
\}  
interface WiFi\{  
 public void open();  
 public void close();  
\}  
  
class Test\{  
 public static void main(String args\[\])\{  
  Phone phone = new Phone();  
  
  USB usb = phone;  
  usb.read();  
  usb.write();  
  
 WiFi wifi = phone;  
 wifi.open();  
 wifi.close();  
 \}  
\}

### 接口可以继承多个接口 ###

什么是接口的应用  
为什么要用接口  
工厂方法模式  
  
class HPPrinter implements Printer\{  
 public void open()\{  
  System.out.println("HP open");  
 \}  
 public void close()\{  
  System.out.println("HP close");  
 \}  
   
 public void print(String s)\{  
  System.out.println("HP print-->" + s);  
 \}  
\}  
   
  
class CanonPrinter implements Printer\{  
 private void clean()\{  
  System.out.println("clean");  
 \}  
 public void close()\{  
  this.clean();  
  System.out.println("Canon close");  
 \}  
  
  public void open()\{  
  System.out.println("Canon opern");  
\}  
    
  public void print(String s)\{  
   System.out.println("Canon print--->"+s);  
  \}  
  
\}  
  
  
interface Printer\{  
 public void open();  
 public void close();  
 public void print(String s);  
\}  
  
  
class Test\{  
 public static void main(String args\[\])\{  
  //根据用户的选择，生成相应的打印机对象  
  //并且向上转型为Printer类型  
  //Printer getPrinter(int flag)  
  printer.open();  
  printer.print("test");  
  printer.close();  
 \}  
\}

#### 打印机工厂 ####

class PrinterFactory\{  
 public static Printer getPrinter(int flag)\{  
   Printer printer = null;  
  //int flag = 0;  
  if(flag == 0)\{  
   printer = new HPPrinter();  
  \}  
  else(flag == 1)\{  
   printer = new CanonPrinter();  
  \}  
  return printer;  
 \}  
\}  
  
class Test\{  
 public static void main(String args\[\])\{  
  //根据用户的选择，生成相应的打印机对象  
  //并且向上转型为Printer类型  
  //Printer getPrinter(int flag)  
  int flag = 1;  
  
  Printer printer = PrinterFactory.getPrinter(flag);  
  printer.open();  
  printer.print("test");  
  printer.close();  
  \}  
\}

### java当中的异常 ###

什么是异常  
异常的分类  
try...catch...finally结构的使用方法  
  
异常：中断了正常指令流的事件。  
Throwable Exception Error  
  
class TestCheck\{  
 public static void main(String args\[\])\{  
  //check exception  
  Thread.sleep(1000);  
 \}  
\}

#### 属于check异常 ####

class Test\{  
 public static void main(String args\[\])\{  
  System.out.println(1);  
  try\{  
  System.out.println(2);  
   int i = 1 / 0;  
  System.out.println(3);  
  \}  
  catch(Exception e)\{  
   e.printStackTrace();  
   System.out.println(4);  
  \}  
  finally\{  
   System.out.println("finally");  
  \}  
  System.out.println(5);  
  \}  
\}  
  
class TestCheck\{  
 public static void main(String args\[\])\{  
  try\{  
   Thread.sleep(1000);  
  \}  
  catch(Exception e)\{  
   e.printStackTrace();  
  \}  
 \}  
\}  
  
30总结  
程序员对Error无能为力，只能处理Exception  
对异常的处理关系到系统的健壮性  
使用try...catch...finally来处理可能出现异常的代码

### throw的作用 ###

throws的作用  
class User\{  
 private int age;  
 public void setAge(int age) throws Exception\{  
  if(age<0)\{  
   RuntimeException e = new RuntimeException("年龄不能为负数");  
   throw e;  
  \}  
  this.age=age  
 \}  
\}  
  
class Test\{  
 public static void main(String args\[\])\{  
  User user = new User();  
  try\{  
   user.setAge(-20);  
  \}  
  catch(Exception e)\{  
   System.out.println(e);  
  \}  
 \}  
\}  
  
throws Exception谁调用谁处理  
  
32Java当中的IO  
IO操作的目标  
IO的分类方法  
读取文件和写入文件的方法  
  
IO操作的目标  
从数据源当中读取数据，以及将数据写入到数据目的地当中。

### IO的分类： ###

第一种分法：  
输入流  
输出流  
第二种分类：  
字节流  
字符流  
第三种分类：  
节点流  
处理流

### IO当中的核心类 ###

InputStream OutputStream FileInputStream FileOnputStream  
字节流的核心类  
  
InputStream OutputStream所有字节流的父类 抽象类，是不能生成对象的，子类可以生成对象。  
  
核心类的核心方法  
InputStream:     
int read(byte\[\] b,int off,int len)  
OutputStream:  
void write(byte\[\] b,int off,int len)  
  
//第一步：导入类，  
import java.io.\*;  
class Test\{  
 public static void main(String args\[\])\{  
    //声明输入流引用  
    FileInputStream fis = null;  
   //读取文件数据的 输入流，FileInputStream  
   try\{  
     //生成代表输入流的对象  
     fis = new FileInputStream("e:/src/from.text");  
     //读取数据  
     //生成一个字节数组  
     byte \[\] buffer = new byte\[100\];  
     //调用输入流对象的read方法，读取数据  
     //0,代表偏移量，如果是5，那么就从第五个读取  
     fis.read(buffer,0,buffer.length);  
     for(int i = 0;i<buffer.length;i++)\{  
      System.out.println(buffer\[i\]);  
     \}  
   \}  
   catch(Exception e)\{  
    System.out.println(e);  
   \}  
 \}  
\}

#### 字符表达 ####

import java.io.\*;  
  
class Test\{  
 public static void main(String args\[\])\{  
    //声明输入流引用  
    FileInputStream fis = null;  
    //声明输出流的引用  
   FileOutputStream fos = null;  
   //读取文件数据的 输入流，FileInputStream  
   try\{  
     //生成代表输入流的对象  
     fis = new FileInputStream("e:/src/from.txt");  
     //生成代表输出流的对象  
     fos = new FileOutputStream("e:/src/to.txt");  
  
  
     //读取数据  
     //生成一个字节数组  
     byte \[\] buffer = new byte\[100\];  
     //调用输入流对象的read方法，读取数据  
     //0,代表偏移量，如果是5，那么就从第五个读取  
     int temp = fis.read(buffer,0,buffer.length);  
     fos.write(buffer,0,temp);  
  
  
    /\* String s = new String(buffer);  
     //调用一个String对象的trim方法，将会去除掉这个字符串的  
     //首尾空格和空字符  
     s = s.trim();  
     System.out.println(s);\*/  
   \}  
   catch(Exception e)\{  
    System.out.println(e);  
   \}  
 \}  
\}

### 32总结：IO系统的主要目标是为了对数据进行读写操作 ###

数据的流向以JAVA程序为参照物  
IO流可以有三种分类方法  
read方法和write方法

####    33Java当中的IO（二） ####

大文件的读写方法  
字符流的使用方法  
  
import java.io.\*;  
class Test\{  
 public static void main(String args\[\])\{  
    //声明输入流引用  
    FileInputStream fis = null;  
    //声明输出流的引用  
   FileOutputStream fos = null;  
  
   //读取文件数据的 输入流，FileInputStream  
   try\{  
     //生成代表输入流的对象  
     fis = new FileInputStream("e:/src/from.txt");  
     //生成代表输出流的对象  
     fos = new FileOutputStream("e:/src/to.txt");  
  
     //读取数据  
     //生成一个字节数组  
     byte \[\] buffer = new byte\[1024\];  
     while(true)\{  
       int temp = fis.read(buffer,0,buffer.length);  
       if(temp == -1)\{  
         break;  
       \}  
       fos.write(buffer,0,temp);  
     \}  
       
  
     //调用输入流对象的read方法，读取数据  
     //0,代表偏移量，如果是5，那么就从第五个读取  
  
    /\* String s = new String(buffer);  
     //调用一个String对象的trim方法，将会去除掉这个字符串的  
     //首尾空格和空字符  
     s = s.trim();  
     System.out.println(s);\*/  
   \}  
  
   catch(Exception e)\{  
    System.out.println(e);  
   \}  
   finally\{  
     try\{  
  
     fis.close();  
     fos.close();   
    \}  
    catch(Exception e)\{  
      System.out.println(e);  
    \}  
   \}  
 \}  
\}

##### 33字符流：读写文件时，以字符为基础 #####

字节输入流：Reader <--FileReader   
int read(char\[\] c,int off,int len)  
字节输出流：Writer <--FileWriter  
void write(char\[\] c,int off,int len)  
  
import java.io.\*;  
public class TestChar\{  
 public static void main(String args\[\])\{  
   //字符数据流 FileReader  
  FileReader fr = null;  
  FileWriter fw = null;  
  try\{  
    fr = new FileReader("e:/src/from.txt");  
    fw = new FileWriter("e:;/src/to.txt");  
    char\[\] buffer = new char\[100\];  
    int temp = fr.read(buffer,0,buffer.length);  
    fw.write(buffer,0,temp);  
  
    /\*for(int i = 0;i<buffer.length;i++)\{  
     System.out.println(buffer\[i\]);  
   \}\*/  
  \}  
  catch(Exception e)\{  
   System.out.println(e);  
  \}  
   finally\{  
     try\{  
    \}  
    catch(Exception e)\{  
    System.out.println(e);  
    \}  
  \}  
\}  
  
34

#### 节点流和处理流 ####

处理流使用实例  
装饰者（Decorator）模式  
节点流与处理流的关系  
BufferedReader介绍  
一行一行的读取  
  
BufferedReader使用方法，生成BufferedReader对象的方法  
BufferedReader in = new BufferedReader(new FileReader("foo.in"));  
  
处理流，Reader,Writer以及他们所有的子类都属于字符流  
BufferedReader属于字符流，处理流，然后呢，它又是处理流  
全称：字符输入处理流  
  
public String readLine()  
  throws IOException  
import java.io.\*;  
class Test\{  
 public static void main(String args\[\])\{  
  FileReader fileReader = null;  
  BufferReader bufferReader = null;  
  try\{  
    fileReader = new FileReader("e:/src/users.txt");  
    bufferedReader = new BufferedReader(fileReader);  
    String line = null;  
    while(true)\{  
     line = bufferedReader.readLine();  
     if(line == null)\{  
      break;  
     \}  
     System.out.println(line);   
   \}  
  
    /\*String line = bufferedReader.readLine();  
    System.out.println(line);\*/  
    
  \}  
  catch(Exception e)\{  
    System.out.println(e);  
  \}  
  finally\{  
    try\{  
      bufferedReader.close();  
      fileReader.close();  
    \}  
    catch(Exception e)\{  
     System.out.println(e);  
    \}  
  \}  
 \}  
\}

##### 装饰者模式 #####

worker.java  
  
interface worker\{  
 public void doSomeWork();  
\}  
  
class Plumber implements Worker\{  
 public void doSomeWork()\{  
  System.out.println("修水管");  
 \}  
\}  
  
class Carpenter implemments Worker\{  
 public void doSomeWork()\{  
  System.out.println("修门窗");  
 \}  
\}  
  
class AWorker implements Worker\{  
 private Worker worker;  
 public AWorker(Worker worker)\{  
  this.worker = worker;  
 \}  
 public void doSomeWork()\{  
    System.out.println("你好");  
    worker.doSomeWork();  
  \}  
\}  
  
class Test01\{  
 public static void main(String args\[\])\{  
    //生成一个A公司水管工对象  
     Plumber plumber = new Plumber();  
     AWorker aWorker = new AWorker(plumber);  
     aWorker.doSomeWork();  
   
     Carpenter carpenter = new Carpenter();  
     AWorker aWorker2 = new AWorker(capenter);  
     aWorker2.doSomeWork();  
  \}  
\}

##### 35内部类和匿名内部类 #####

什么是内部类？  
内部类的使用方法  
匿名内部类的使用方法  
  
  
class A\{  
  class B\{  
   
  \}  
\}  
  
如何生成内部类的对象？  
  
class Test\{  
 public static void mian(String args\[\])\{  
  A a = new A();  
  A.B b = a.new B();  
 \}  
\}  
  
class A\{  
 int i;  
 class B\{  
  int j;  
    
  int funB()\{  
    int result = i + j;  
    return result;  
  \}  
 \}  
\}  
  
class Test\{  
 public static void main(String args\[\])\{  
  A a = new A();  
  A.B b = a.new B();  
    
  a.i = 3;  
  b.j = 1;  
  int result = b.funB();  
  System.out.println(result);   
  \}  
\}  
  
class A\{  
 int i;  
  
 class B\{  
  int j;  
   
  int funB()\{  
   int result = A.this.i + this.j;  
   return result;  
  \}  
 \}  
\}

####    匿名内部类 ####

interface A\{  
 public void doSomething();  
\}  
  
class B\{  
 public void fun(A a)\{  
  System.out.println("B类的fun函数");  
  a.doSomething();  
  \}  
\}  
  
class AImpl implements A\{  
 public void doSomething()\{  
  System.out.println("doSomething");  
 \}  
\}  
  
class Test\{  
 public static void main(String args\[\])\{  
  AImpl al = new AImpl();  
  A a = al;  
  
  B b = new B();  
  b.fun(a);  
  \}  
\}  
  
匿名内部类  
class Test\{  
 public static void main(String args\[\])\{  
  //AImpl al = new AImpl();  
  ///A a = al;   
  
  B b = new B();  
  b.fun(new A()\{  
   public void doSomething()\{  
    System.out.println("匿名内部类");  
   \}  
  \});  
 \}  
\}

### 36Java当中的线程 ###

1.进程和线程  
2.多线程程序运行模式  
3.定义线程的方法

### 多线程与多进程 ###

多进程：  
在操作系统中能（同时）运行多个任务（程序）  
多线程：  
在同一应用程序中多个顺序流（同时）执行

#### 创建线程的方法 ####

方法1：  
定义一个线程类，它继承类Thread并重写其中的方法run();方法run()称为线程体；由于Java只支持单继承，用这种方法定义的类不能再继承其他类。  
  
FirstThread.java  
class FirstThread extends Thread\{  
 public void run()\{  
    for(int i=0;i<100;i++)\{  
     System.out.println("FirstThread"+i);  
  
    \}  
 \}  
\}  
  
  
class Test\{  
 public static void main(String args\[\])\{  
  //生成线程类的对象  
  FirstThread ft = new FirstThread();  
  //启动线程  
  ft.start();  
   
  //ft.run();  千万不能这样写  
  for(int i = 0;i<100;i++)\{  
   System.out.println("main"+i);  
   \}  
  \}  
\}  
  
37

##### 实现线程的第二种方法 #####

控制线程的常用函数  
  
方法二：提供一个实现接口Runnable的类作为线程的目标对象，在初始化一个Thread类或者Thread子类的线程对象时，把目标对象传递给这个线程实例，由该目标对象提供线程体。  
  
class RunnableImpl implements Runable\{  
 public void run()\{  
  for(int i = 0;i<100;i++)\{  
   System.out.println("Runnable-->"+i);  
  \}  
 \}  
\}  
  
class Test\{  
 public static void main(String args\[\])\{  
  //生成一个Runnable接口实现类的对象  
  //ri 代表的是线程体  
  RunnableImpl ri = new RunnableImpl();  
  //生成一个Thread对象，并将Runnable接口实现类的对象作为参数  
  //传递给该Thread对象  
  //代表的是线程  
  
  Thread t = new Thread(ri);  
  System.out.println(t.getPriority());  
  //通知Thread对象，执行start方法  
  t.start();  
  \}  
\}

#### 线程的简单控制方法 ####

中断线程  
Thread.sleep();  
Thread.yield();//让出自己正在使用的CPU  
  
设置线程的优先级  
getPriority();  
setPriority();  
  
class RunnableImpl implements Runnable\{  
 public void run()\{  
  for(int i=0;i<100;i++)\{  
   System.out.println("Runnable-->"+i);  
   if(i==50)\{  
  
     try\{  
     Thread.sleep(2000);  
     \}  
     catch(Exception e)\{  
       System.out.println(e);  
     \}  
   \}  
  \}  
 \}  
\}  
  
  
class Test\{  
 public static void main(String args\[\])\{  
  //生成一个Runnable接口实现类的对象  
  RunnableImpl ri = new RunnableImpl();  
  
  //生成一个Thread对象，并将Runnable接口实现类的对象作为参数  
  //传递给该Thread对象  
  Thread t = new Thread(ri);  
  
  //线程的优先级最大是10，最小是1，可以使用Thread所提供的静态常理来设置线程的优先级  
  
  t.setPriority(Thread.MAX\_PRIORITY);  
  
  //t.setPriority(Thread.MIN\_PRIORITY);  
  //通知Thread对象，执行start方法  
  
  t.start();  
  System.out.println(t.getPriority());  
  \}  
\}  
  
38

##### 多线程数据安全 #####

同步线程的方法  
   
class Test\{  
 public static void main(String args\[\])\{  
  MyThread myThread = new MyThread();  
  
  //生成两个Thread对象，但是这两个Thread对象共用同一个线程体  
    
  Thread t1 = new Thread(myThread);  
  Thread t2 = new Thread(myThread);  
    
  //每一个线程都有名字，可以通过Thread对象的setName()方法设置线程名字，也可以使用getName方法获取线程的名字  
  
  t1.setName("线程a");  
  t2.setName("线程b");  
   
  //分别启动两个线程  
  t1.start();  
  t2.start();  
  \}  
\}  
  
  
class MyThread implements Runnable\{  
 int i = 100;  
 public void run()\{  
  while(true)\{  
  System.out.println(Thread.currentThread().getName()+i);  
  i--;  
  Thread.yield();  
  if(i<0)\{  
   break;  
  \}  
 \}  
 \}  
\}  
//同步代码块  
class MyThread implements Runnable\{  
 int i = 100;  
 public void run()\{  
  while(true)\{  
   synchronized(this)\{  
    //Thread.currentThread();  
    System.out.println(Thread.currentThread().getName()+i);  
    i--;  
    Thread.yield();  
    if(i<0)\{  
     break;  
    \}  
   \}  
  \}  
 \}  
\}

#### 39深入同步语法 ####

##### 深入synchronized关键字 #####

class Service\{  
 public void fun1()\{  
  synchronized(this)\{  
   try\{  
    Thread.sleep(3\*1000);  
   \}  
   catch(Exception e)\{  
    System.out.println(e);  
   \}  
   System.out.println("fun1");  
   \}  
  \}  
    
  public void fun2()\{  
    synchronized(this)\{  
      System.out.println("fun2");  
    \}  
  \}  
\}  
  
class MyThread1 implements Runnable\{  
 private Service service;  
   
 public MyThread1(Service service)\{  
  this.service = service;  
 \}  
 public void run()\{  
  service.fun1();  
 \}  
\}  
  
class MyThread2 implements Runnable\{  
 private Service service;  
   
 public MyThread2(Service service)\{  
  this.service = service;  
 \}  
 public void run()\{  
  service.fun2();  
 \}  
\}  
  
  
class Test\{  
 public static void main(String args\[\])\{  
  Service service = new Service();  
  
  Thread t1 = new Thread(new MyThread1(service));  
  Thread t2 = new Thread(new MyThread2(service));  
  
  t1.start();  
  t2.start();  
  \}  
\}  
  
同步锁 锁住的是service  
  
同步方法,同步代码块锁住this  
  
class Service\{  
 public synchronized void fun1()\{  
  try\{  
   Thread.sleep(3\*1000);  
  \}  
  catch(Exception e)\{  
   System.out.println(e);  
  \}  
  
  System.out.println("fun1");  
 \}  
   
  public void fun2()\{  
   synchronized(this)\{  
    System.out.println("fun2");  
   \}  
  \}  
\}

#### 40JAVA当中的数组 ####

数组的类型  
数组的定义方法  
数组的操作方法  
  
class Test\{  
 public static void main(String args\[\])\{  
  //数组的静态声明  
  int arr \[\] = \{5,2,7,8,9,0\};  
  arr\[3\] = 10;  
  //System.out.println(arr\[3\]);  
  for(int i = 0;i<5;i++)\{  
    System.out.println(arr\[i\]);  
   \}  
  \}  
\}  
  
  
class Test\{  
 public static void main(String args\[\])\{  
  int arr\[\] = \{2,4,6,7,8\};  
  System.out.println(arr.length);  
  \}  
\}  
  
数组的动态声明  
class Test\{  
 public static void main(String args\[\])\{  
   
 //动态声明  
 int arr \[\] = new int \[10\];  
 System.out.println("arr数组长度"+arr.length);  
   for(int i = 0;i<arr.length;i++)\{  
    System.out.println(arr\[i\]);  
   \}  
 \}  
\}

##### 二维数组定义方法 #####

class Test\{  
 public static void main(String args\[\])\{  
  //二维数组的定义方法，长度为3  
   int arr \[\]\[\] = \{ \{1,2,3\},\{4,5,6\},\{7,8,9\}\}；  
   System.out.println(arr\[1\]\[1\]);  
   for(int i = 0; i < 3; i++)\{  
    for(int j = 0; j < 3; j++)\{  
     System.out.println(arr\[i\]\[j\]);  
    \}  
   \}  
 \}  
\}  
  
优化  
class Test\{  
 public static void main(String args\[\])\{  
  //二维数组的定义方法，长度为3  
  
   int arr \[\]\[\] = \{ \{1,2,3\},\{4,5,6\},\{7,8\}\}；  
   System.out.println(arr\[1\]\[1\]);  
   for(int i = 0; i < arr.length; i++)\{  
    for(int j = 0; j < arr\[i\].length; j++)\{  
     System.out.println(arr\[i\]\[j\]);  
    \}  
   \}  
 \}  
\}  
  
动态  
class Test\{  
 public static void main(String args\[\])\{  
  
   //int arr \[\]\[\] = \{ \{1,2,3\},\{4,5,6\},\{7,8\}\}；  
   int arr \[\]\[\] = new int\[3\]\[5\];   
   System.out.println(arr\[1\]\[1\]);  
   for(int i = 0; i < arr.length; i++)\{  
    for(int j = 0; j < arr\[i\].length; j++)\{  
     System.out.println(arr\[i\]\[j\]);  
    \}  
   \}  
 \}  
\}  
   
41类集框架  
什么是类集框架  
集合的种类  
类集框架的基础结构

## 什么是类集框架 ##

1.类集框架是一组类和接口；  
2.位于java.util包当中；  
3.主要用户存储和管理对象；  
4.主要分为三大类---集合，列表和映射

### 什么是集合（Set） ###

集合中的对象不按特定的方式排序，并且没有重复对象；  
  
对象是没有顺序的，集合是没有顺序的

### 什么是列表（List） ###

集合中对象按照索引位置排序，可以有重复的对象。  
可以按照顺序取，也可以指定取。

#### 什么是映射（Map） ####

集合中的每一个元素包含一个键对象和一个值对象，键不可以重复，值可以重复。  
数据结构 键值对

##### 类集框架主体结构 #####

interface  
Iterator Collection  
ListIterator List Set Map  
LinkeList ArrayList HashSet SortedSet HashMap SortedMap  
LinkedHashSet TreeSet LinkedHashMap TreeMap  
Comparable Comparator Collections Arrays  
  
//arrayList默认10,可无限长，关于泛型  
  
Test.java  
import java.util.List;  
import java.util.ArrayList;  
  
public class Test\{  
 public static void main(String args\[\])\{  
  
  //ArrayList arrayList = new ArrayList();  
  ArrayList<String> arrayList = new ArrayList<String>();  
  
  arrayList.add("a");  
  arrayList.add("b");  
  arrayList.add("c");  
  
  //String s = arrayList.get(1);  
  //System.out.println(s);  
  
   for(int i=0;i<3;i++)\{  
    String s = arrayList.get(i);  
    System.out.println(s);  
   \}  
  \}  
\}  
  
优化

import java.util.List;
    import java.util.ArrayList;
    
    public class Test{
     public static void main(String args[]){
      ArrayList<String> arrayList = new ArrayList<String>();
      
      arrayList.add("a");
      arrayList.add("b");
      arrayList.add("c");
      arrayList.add("d");
      
      for(int i = 0; i < arrayList.size(); i++){
       String s = arrayList.get(i);
      }
     }
    }

import java.util.List;
    import java.util.ArrayList;
    
    
    public class Test{
     public static void main(String args[]){
      ArrayList<String> arrayList = new ArrayList<String>();
      arrayList.add("a"); 
      arrayList.add("b");
      arrayList.add("c");
      arrayList.add("d");
    
      arrayList.remove(1);
    
      for(int i = 0; i<arrayList.size();i++){
       String s = arrayList.get(i);
       System.out.println(s);
      }
     }
    }

#### 类集框架 ####

集合 无序 不可重复  
列表 有序 可重复  
映射

#### Collection和Iterator接口 ####

##### Set与HashSet的使用方法 #####

##### Collection 接口（一） #####

boolean add(Object o) 向集合当中加入一个对象  
void clear() 删除集合当中的所有对象  
boolean isEmpty() 判断集合是否为空  
remove(Object o) 从集合中删除一个对象的引用  
int size() 返回集合中元素的数目  
  
Set继承了Collection

不可以重复

import java.util.Set;
    import java.util.HashSet;
    
    public class Test{
      public static void main(String args[]){
    
       //HashSet<String> hashSet = new HashSet<String>();
       //Set<String> set = new HashSet<String>();
       
      //别管就是转，方便
       Set<String> set = new HashSet<String>();
    
       boolean b1 = set.isEmpty();
       System.out.println(b1);
    
       set.add("a");
       set.add("b");
       set.add("c");
       set.add("d");
       set.add("c");
        
       boolean b2 = set.isEmpty();
       System.out.println(b2);
       
       int i = set.size();
       
       System.out.println("clear之前的长度"+i);
     
       set.clear();
       
       int j = set.size();
     
       System.out.println(j);
      }
    }

取数据，迭代  iterate器 (Iterator)

import java.util.Set;
    import java.util.HashSet;
    import java.util.Iterator;
    public class Test{
     public static void main(String args[]){
      //HashSet<String> hashSet = new HashSet<String>();
      //Set<String> set = hashSet;
      //Iterator <-- Collection <-- Set <-- HashSet
      //hasNext() next()
    
      Set<String> set = new HashSet<String>();
      
      set.add("a");
      set.add("b");
      set.add("c");
      set.add("d");
      set.add("c");
     
      //生成迭代器对象
      //调用Set对象的Iterator方法，会生成一个迭代器对象，该对象用于遍历整个Set
       Iterator<String> it = set.iterator();
       boolean b1 = it.hasNext();
       if(b1){
        String s = it.next();
        System.out.println(s);
       }
       boolean b2 = it.hasNext();
       if(b2){
        String s = it.next();
        System.out.println(s);
       }
      }
    }

#### 迭代器的使用 ####

it.hasNext();  
还有没有下一个元素，如果这个游标后面有元素就返回true，否则,false;  
  
it.next();  
返回游标所指位置的下一个元素，取出，用hasNext()看有没有，next取  
  
  
ok

import java.util.Set;
    import java.util.HashSet;
    import java.util.Iterator;
    
    public class Test{
     public static void main(String args[]){
      //HashSet<String> hashSet = new HashSet<String>();
      //Set<String> set = hashSet;
      //Iterator <-- Collection <-- Set <-- HashSet
      //                        <--List <--ArrayList
      //has Next() next()
      Set<String> set = new HashSet<String>();
     
      set.add("a");
      set.add("b");
      set.add("c");
      set.add("d");
      set.add("c");
      
      Iterator<String> it = set.iterator();
    
      while(it.hasNext()){
       String s = it.next();
       System.out.println(s);
    
      }
     }
    }

43Map

### Map与HashMap的使用方法 ###

JDK帮助文档

##### 什么是映射（Map） #####

映射中的每一个元素包含一个键对象和一个值对象，键不可以重复，值可以重复。  
  
Map存的是一对

import java.util.Map;
    import java.util.HashMap;
    
    public class Test{
     public static void main(String args[]){
      HashMap<String,String> hasMap = new HashMap<String,String>()；
    
      Map<String,String> map = hasMap;
    
      map.put("1","a");
      map.put("2","b");
      map.put("3","c");
      map.put("4","d");
      
      int i = map.size();
     
      System.out.println(i);
      }
    }

import java.util.Map;
    import java.util.HashMap;
    
    public class Test{
     public static void main(String args[]){
      HashMap<String,String> hashMap = new HashMap<String,String>();
      Map<String,String> map = hashMap;
    
      map.put("1","a");
      map.put("2","b");
      map.put("3","c");
      map.put("4","d");
      map.put("3","e");
    
      String s = map.get("3");
      System.out.println(s);
      }
    }

import java.util.Map;
    import java.util.HashMap;
    
    public class Test{
     public static void main(String args[]){
      HashMap<String,String> hashMap = new HashMap<String,String>();
      Map<String,String> map = hashMap;
    
      map.put("1","a");
      map.put("2","b");
      map.put("3","c");
      map.put("4","d");
      map.put("3","e");
    
      int i = map.size();
      System.out.println(i);
    
      String s = map.get("3");
      System.out.println(s);
    
      }
    }

从入门到熟悉！

坚决不放弃！

![2_02.png_wx_lazy_1][]

喜欢本文的朋友们

欢迎长按下图关注订阅号醉翁猫咪

收看更多精彩内容

![20180207232731563][]

[20180207231814861]: /images/20210724/a90396c85c1542e38f7c4c1f2feff8f5.png
[2_02.png_wx_lazy_1]: /images/20210724/345764c288164f4686662ebec3e2e8d1.png
[20180207232731563]: /images/20210724/a6716e42d60c4b7e9d8aeab459de592b.png