java入门笔记17

Iterator迭代器

Collection接口继承Iterable接口,在该接口中包含一个名为iterator的抽象方法，所有实现了Collection接口的容器类对该方法做了具体的实现。

iterator接口定义如下方法：

• boolean hasNext();//判断游标当前位置是否有元素。
• Object next();//获取当前游标所在位置的元素，并将游标移动到下一个位置。
• void move();//删除游标当前位置的元素，在执行完next后该操作只能执行一次。

迭代器的使用

package cpm.bjsxt.test2;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorListTest {

    public static void main(String[] args) {
        //实例化容器
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        //获取元素
        //获取迭代器对象
        Iterator<String>  iterator=list.iterator();
        //方式一:通过while循环获取元素
        while(iterator.hasNext()){
            String value=iterator.next();
            System.out.println(value);
        }
        System.out.println("==========");
        //方式二:通过for循环获取元素
        for(Iterator<String> it=list.iterator();it.hasNext();){
            System.out.println(it.next());
        }
    }
}

使用Iterator迭代Set接口类型容器

package cpm.bjsxt.test2;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class IteratorSetTest {
    //Map接口没有Iterator接口,不可以直接利用迭代器
    public static void main(String[] args) {
        //实例化Set容器
        Set<String> set=new HashSet<>();
        set.add("a");
        set.add("b");
        set.add("c");

        //方式一:通过while循环
        //获取迭代器对象
        Iterator<String> iterator=set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("========");
        //方式二：通过for循环
        for(Iterator<String>  it=set.iterator();it.hasNext();){
            System.out.println(it.next());
        }
    }
}

在迭代器中删除元素

package cpm.bjsxt.test2;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorRemoveTest {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        int flag=-1;
        Iterator<String> it=list.iterator();

        while(it.hasNext()){
            //不要在迭代器中多次调用next方法
            String v=it.next();
            if("c".equals(v)) {
                it.remove();
            }
        }
        for(Iterator<String> it1=list.iterator();it1.hasNext();){
            System.out.println(it1.next());
        }
/**   其它删除元素的方法
        for(int i=0;i<list.size();i++){
            if("c".equals(list.get(i))) {
                flag = i;
            }
        }
        if(flag>-1){
            list.remove(flag);
        }
        for(int i=0;i<list.size();i++){
        if("c".equals(list.get(i))){
        list.remove(i);
        }
       //     list.remove(2)
       //     输出结果：a b 删除元素后，元素位置会移前，所以不要再循环里面删除元素
       System.out.println(list.get(i));}

        for(String str:list){
            if("c".equals(str)){
                list.remove("c");
            }
            //不可以添加元素
        }
        for(String str:list){
            System.out.println(str);
        }
 */
    }
}

Collection

Collections是一个工具类，提供了对Set，List，Map进行排序，填充，查找元素的辅助静态方法。

常用方法

• void sort(List) //对List容器内的元素排序，排序的规则是按照升序进行排序
• void shuffle(List) //对List容器内的元素进行随机排序
• void reverse(List) //对List容器内的元素进行逆序
• void fill(List,Object)//用一个特定的对象重写整个List容器
• int binarySearch(List,Object)//对于顺序的List容器，采用折半查找的方法查找特定的对象

Collections工具类常用方法使用代码

package cpm.bjsxt.test2;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsSortTest {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("c");
        list.add("b");
        list.add("d");
        list.add("a");
        //通过Collections工具类的sort方法完成排序
         Collections.sort(list);    //进行升序
        for(String str:list){
            System.out.println(str);
        }
        System.out.println("===============");
        Collections.shuffle(list);  //进行随机排序
        for(String str:list){
            System.out.println(str);
        }
    }
}

简单题目

1.两数之和（简单）

简单的类型顺序第一题

题目：1.给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个
整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

• 解题思路： 遍历数组，让数组中的每个元素进行两两相加，如果等于这个目标数，把它的下标保存到我的数组里面，且确保小的下标在前面。（题目中说到可以假设每种输入只会对应一个答案，于是我就定义了一个长度为2的整型数组去保存找到的下标。）

• 解题代码：

class Solution {
    public   static int[] twoSum(int[] nums, int target) {
        int[]  bb=new int[2];
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                if((nums[i]+nums[j])==target){
                    bb[0]=i;
                    bb[1]=j;                   
                }
            }
        }
        return bb;
    }
}

2.回文数（简单）

简单的类型，顺序第2题目

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。 例如，121 是回文，而 123 不是。
示例 1： 输入：x = 121
输出：true
示例 2： 输入：x = -121 输出：false 解释：从左向右读, 为 -121 。 从右向左读, 为 121-因此它不是一个回文数。
示例 3：输入：x = 10
输出：false 解释：从右向左读, 为 01 。因此它不是一个回文数。

解题思路
1.先假设满足，设flag=true。
2.如果x<0，flag=false。
3.如果下x>0。因为不确定这个整数是几位数，我先通过 while(x!=0){
x=x/10;
b++; //计数,b=0
} 来判断x是几位数
4.然后进行将x拆分，把它的每一位数字都拆出来
5.把每一位拆分出来的数字乘以对应的位数（个、十、百）对于的10的倍数。然后通过求和的sum与原来的x进行比较。
6.sum=x，flag=true；sum！=x,flag=false;
7.返回flag。
解题代码

class Solution {
    public boolean isPalindrome(int x) {
        int b=0;
        int k=x,sum=0,N=x;
        boolean flag=true;
        if(x<0){
            flag=false;
        }else{
        while(x!=0){
            x=x/10;
            b++;
        }
        for(int i=0;i<b;i++){
            int a,c=1;
            a=k%10;
            k=k/10;
            for(int j=i+1;j<b;j++){
                c*=10;
            }
            sum+=a*c; 
        }
        if(sum==N){
           flag=true;
        }else{
             flag=false;
        }
        }
         return flag;
    }
}