java的日常使用

本文主要是介绍java的日常使用，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1. 输入输出流处理

import java.util.Scanner;
Scanner sc = new Scanner(System.in);
sc.nextInt(); //下一个整数
sc.nextDouble(); //下一个浮点数
sc.nextLine(); //下一行
sc.hasNextLine(); //是否有下一行
sc.hasNext(); //是否有下一个输入

30 20 35 40
20 18 25 30
50
public class Main {
    public static void main(String[] args) {
		//输入代码
		Scanner sc = new Scanner(System.in);
        //总共三行输入
        String a1 = sc.nextLine();
        String a2 = sc.nextLine();
        String[] a11 = a1.split(" ");
        String[] a22 = a2.split(" ");
        Integer[] key = new Integer[a22.length];
        int disLimit = sc.nextInt();
        //采用Map进行存储
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for(int i = 0; i < a11.length; i++){
            if(Integer.valueOf(a22[i]) <= disLimit){
                map.put(Integer.valueOf(a22[i]), Integer.valueOf(a11[i]));
                key[i] = Integer.valueOf(a22[i]);
        }
    }

2.基本数据类型 ——字符串处理

• String:

// 强转
byte[] b={97,98,99,100,101,102};
String str=new String(b,3,2);
System.out.println(str);

// 遍历字符串
String s="abcde";
for(int i=0;i<s.length();i++){
	char c=s.charAt(i);
	System.out.print(c+" ");//输出a b c d e，获取字符串
}
String[] s1={"a","b","c","d","e"};
for(int i=0;i<s1.length;i++){
	System.out.print(s1[i]+" ");//输出a b c d e，获取字符串数组
}

// 把String字符串转换为数字
String   s   =   "123.456 ";  
double   d   =   Double.parseDouble(s); 
float   f   =   Float.parseFloat(s);
int i = Integer.parseInt(str);//str待转换的字符串

// indexof作用
// str.indexOf(',')，表示在整个str字符串中检索！
// int n3 = str.indexOf(',',n1);表示从n1开始检索！
public static void main(String[] args) {
       String str="Hello, world, !";
       int n1 = str.indexOf(',');
       System.out.println(n1);
       int n2 = str.indexOf(',',n1+1);
       System.out.println(n2);
       int n3 = str.indexOf(',',n1);
       System.out.println(n3);
       System.out.println(str.startsWith("H"));
       System.out.println(str.endsWith("!"));
 }
// Java里面分离小数点要用到转义字符，否则得不到正确答案
String []s = str.split("\\.");

• StringBuffer:
• append（）、insert（）、replace（）、delete（）、reserve（）

  • public StringBuffer append(String s)：将指定的字符串追加到此字符序列。

  • StringBuffer insert（int index，String str）：在index前插入字符串。

  • replace(int start, int end, String str)：使用给定 String 中的字符替换此序列的子字符串中的字符。

  • public delete(int start, int end)：移除此序列的子字符串中的字符。（从start开始，包含start，到end结束，不包含end）

  • public StringBuffer reverse()：将此字符序列用其反转形式取代。

public class Str {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuffer sb = new StringBuffer("good");
		sb.append(" study");
		System.out.println(sb);
		sb.reverse();
		System.out.println(sb);
		sb.delete(1,3);  //删除下标1和2
		System.out.println(sb);
		sb.insert(3, "hello");
		System.out.println(sb);
		sb.insert(0, "11");
		System.out.println(sb);
		sb.replace(1, 2, "hello");
		System.out.println(sb);
	}
}
// output:
// good study
// yduts doog
// yts doog
// ytshello doog
// 11ytshello doog
// 1helloytshello doog

3.基本数据类型——列表

package one;
import java.util.*;
public class Array{
	    public static void main(String args[]) {
	        // 创建一个空的数组链表对象list，list用来存放String类型的数据
	        ArrayList<String> list = new ArrayList<String>();

	        // 增加元素到list对象中
	        list.add("Item1");
	        list.add("Item2");
	        list.add(2, "Item3"); // 此条语句将会把“Item3”字符串增加到list的第3个位置。
	        list.add("Item4");

	        // 显示数组链表中的内容
	        System.out.println("The arraylist contains the following elements: "  + list);

	        // 检查元素的位置
	        int pos = list.indexOf("Item2");
	        System.out.println("The index of Item2 is: " + pos);

	        // 检查数组链表是否为空
	        boolean check = list.isEmpty();
	        System.out.println("Checking if the arraylist is empty: " + check);

	        // 获取链表的大小
	        int size = list.size();
	        System.out.println("The size of the list is: " + size);

	        // 检查数组链表中是否包含某元素
	        boolean element = list.contains("Item5");
	        System.out.println("Checking if the arraylist contains the object Item5: " + element);

	        // 获取指定位置上的元素
	        String item = list.get(0);
	        System.out.println("The item is the index 0 is: " + item);

	        // 遍历arraylist中的元素

	        // 第1种方法: 循环使用元素的索引和链表的大小
	        System.out.println("Retrieving items with loop using index and size list");
	        for (int i = 0; i < list.size(); i++) {
	            System.out.println("Index: " + i + " - Item: " + list.get(i));
	        }

	        // 第2种方法:使用foreach循环
	        System.out.println("Retrieving items using foreach loop");
	        for (String str : list) {
	            System.out.println("Item is: " + str);
	        }

	        // 第三种方法:使用迭代器
	        // hasNext(): 返回true表示链表链表中还有元素
	        // next(): 返回下一个元素
	        System.out.println("Retrieving items using iterator");
	        for (Iterator<String> it = list.iterator(); it.hasNext();) {
	            System.out.println("Item is: " + it.next());
	        }

	        // 替换元素
	        list.set(1, "NewItem");
	        System.out.println("The arraylist after the replacement is: " + list);

	        // 移除元素
	        // 移除第0个位置上的元素
	        list.remove(0);

	        // 移除第一次找到的 "Item3"元素
	        list.remove("Item3");

	        System.out.println("The final contents of the arraylist are: " + list);

	        // 转换 ArrayList 为 Array
	        String[] simpleArray = list.toArray(new String[list.size()]);
	        System.out.println("The array created after the conversion of our arraylist is: "+ Arrays.toString(simpleArray));
	    }
	}

• 排序：

/**
     * 数字排序
     */
    @Test
    public void t2() {
        List<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(4);
        list.add(8);
        list.add(5);
        list.add(6);
//        list.sort(new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                //升序
                return o1-o2;
//                //降序
//                return o2 - o1;
//            }
//        });
        //使用 Lambda 表达式
        //升序
        //list.sort((o1, o2) -> o1 - o2);
        //降序
        list.sort((o1, o2) -> o2 - o1);
        System.out.println(list);
    }

/**
     * 字符串排序
     */
    @Test
    public void t3() {
        List<String> list = new ArrayList<>();
        list.add("2");
        list.add("4");
        list.add("du");
        list.add("f");
        list.add("7");
//        list.sort(new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                //升序
                return o1.compareTo(o2);
//                //降序
//                return o2.compareTo(o1);
//            }
//        });
        //使用 Lambda 表达式
        //升序
        list.sort(String::compareTo);
        //或
//        list.sort((o1, o2) ->o1.compareTo(o2));
        //
        //降序
//        list.sort(Comparator.reverseOrder());
        //或
//        list.sort((o1, o2) ->o2.compareTo(o1));
        System.out.println(list);
    }

• 堆排序：
  https://leetcode-cn.com/problems/sort-an-array/solution/pai-xu-shu-zu-by-leetcode-solution/

 
import java.util.Arrays;
/**
 * 
 * @author Administrator
 *
 */
public class HeapSort {
    public static void main(String []args){
        int []arr = {7,6,7,11,5,12,3,0,1};
        System.out.println("排序前："+Arrays.toString(arr));
        sort(arr);
        System.out.println("排序前："+Arrays.toString(arr));
    }
 
    public static void sort(int []arr){
        //1.构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }
 
    }
 
    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustHeap(int []arr,int i,int length){
        int temp = arr[i];//先取出当前元素i
        for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }
        arr[i] = temp;//将temp值放到最终的位置
    }
 
    /**
     * 交换元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a ,int b){
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

这篇关于java的日常使用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！