javaSE(从0开始)day03-优快云博客

        int a=5;
        int b=6;
        System.out.println("& 按位与："+(a&b));  //101  &  110 结果为100 =4
        System.out.println("| 按位或："+(a|b));// 101 | 110  结果为111 =7
        System.out.println("^ 按位异或："+(a^b));//101 ^110  结果为  11 =3  (异或：不同为1，相同为0)
        System.out.println("<< 按位与："+(a<<b));
        System.out.println(">>按位与："+(a>>b));

       //非运算 ~
        int c=27;
        int c1=~c;
        System.out.println(c1);  //-28

2.利用位运算做一些运算：位运算可以提高效率

1 .与运算，判断奇偶数

         int b1 = 82;//与运算，判断奇偶数
         boolean b2=(b1&1)==1;//判断是否为奇数
         boolean b3=(b&1)==0;//判断是否为偶数
        System.out.println("判断是否为奇数:"+b2);
        System.out.println("判断是否为偶数:"+b3);

2.异或运算（交换两个数）

//（1）定义临时变量交换。

       //定义临时变量进行两个整数的交换
        int aa=8;
        int bb=5;
        int temp =aa;
        aa = bb;
        bb= temp;
        System.out.println("aa:"+aa+" bb:"+bb);

//（2）利用异或交换异或公式： x^x=0 x^0=x

       //交换两数 ^  x^0=x   x^x=0
        int s1=5;
        int s2=8;
        s1=s1^s2;
        s1=s1^s2;
        s1=s1^s2;
        System.out.println("s1:"+s1+" s2:"+s2);

//（3）//& 和 ^ 混合使用；求平均值，防止溢出

        int a2=2147483647;
        int a3=2147283245;
        int avg1 =(a2& a3)+((a2^a3)>>1);
        //a2 & a3 将相同的二进制位数提出来， a2^a3 将不同的二进制位数提出来
        // >> 求二进制不同位置两数相差值的均值，用相同位数加均值就是两数的平均值

        System.out.println(avg1);

二、三元运算符

定义：表达式1？表达式二 : 表达式3；

其中表达式1结果为布尔类型，若表达式1 成立，执行表达式2，不成立，执行表达式3（表达式2与表达式3为同一类型）相当于一个条件判断语句。

        int score =80;
        char ch =score>=80? 'A':(score>=60? 'B':'C');
        System.out.println(ch);

三、字符串（引用数据类型）

1.定义：被双引号“ ”引起来的字符为字符串。

2.字符串可以为空。

3.字符串可以值为null

4 字符串有不可变的特性：

字符串一旦被定义，相当于开辟了一个内存地址，不可摧毁发生改变，但是可以改变变量名的指向地址。

        String s1="";//字符串可以为空
        String s2="中国人3tf#%7bnc";//字符串可以包含任意字符
        String s3="他说： \"暑假时弯道超车的好时候\"";//可以使用\进行转义
        String s4="他说： \n暑假时弯道超车的好时候\t";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);

         String  str1 =null;//可以为null

        //字符串的不可变特性
        String str ="hello";
       // 相当于又在堆里面开辟了一个内存地址存放world, 将str指向world 的内存地址,hello仍存在
        str ="world";

5.字符串的常用方法：

（1）int length()

       String s1="";//字符串可以为空
        String s2="中国人3tf#%7bnc";//字符串可以包含任意字符
        String s3="他说： \"暑假时弯道超车的好时候\"";//可以使用\进行转义
        String s4="他说： \n暑假时弯道超车的好时候\t";
        String s5=null;
        //int length();返回字符串的长度
        int len1=s1.length();
        System.out.println(len1);
        System.out.println(s2.length());
        System.out.println(s3.length());
        System.out.println(s4.length());
//        System.out.println(s5.length());   //发生异常报错空指针异常

（2）char charAt(int index) 注意下标在 0 ~（长度-1）范围内，超过范围报异常下标越界.

        //char charAt(int index)
        //注意 下标在 0 ~（长度-1）范围内，超过范围报异常 下标越界
        String str ="我本将心向明月";
        char first =str.charAt(0);
//        char first =str.charAt(1000); //报下标越界异常
        int len=str.length();
        char last=str.charAt(len-1);
        System.out.println("首字符："+first);
        System.out.println("尾字符："+last);

(3) 大小写转换 toUpperCase() 、toLowerCase()、

       //字符串大小写转换
        String str1 = "AbCd";
        String str2 = "abCD";
        //字符串转成大写String toUpperCase()或者小写StringtoLowercase()
        //转大写操作，生成新的字符串
        String upperStr= str1.toUpperCase();
        System.out.println(upperStr);
         //转小写操作，生成新的字符串
        String lowerStr=str.toLowerCase();
        System.out.println(lowerStr);
        //如果想要让str改变，需要重新指向
        str = lowerStr;
        System.out.println(str);

(4)字符串的判断（内容师傅相等.equals(String str) 地址是否相等==）

        //str1 =str1.toLowerCase();//abcd
        //str2=str2.toLowerCase();//abcd/
        // 字符串是引用数据类型，==对于引用数据类型来说，比较的是地址//字符串内容比较
        //判断字符串地址  == 判断字符串内容 equals() 或qualsIgnoreCase() 忽略大小写
        System.out.println("地址是否一样:"+(str1 == str2));
        System.out.println("内容是否一样:"+str1.equals(str2));
        //忽略大小写内容比较
        boolean b1=str1.equalsIgnoreCase(str2);
        System.out.println("忽略大小写内容是否一样:"+b1);

（5）字符串的截取：

subtring(begin，end) 从 begin下标开始，到end下标结束，不包括end 范围[begin, end）

subtring(begin) 从 begin下标开始，到字符串结束，范围[begin, str.length()-1]

         String s1="我本将心向明月，奈何明月照沟渠";
//        subString(begin,end)截取字符串，范围[begin,end)
        String sub1= s1.substring(8,15);
        System.out.println(sub1);
        String sub2=s1.substring(8);// 截取字符串从下表8（包含8）开始到字符串结束

(6)字符或字符串的查找

index0f('’/"")查找某个字符|字符串首次出现的下标位置，如果未出现，返回值为-1

indexOf(''/"",int index) 从index下标所对应位置后开始查找。

lastIndexOf('' | "" )查找某个字符|字符串最后一次出现的下标位置，如果未出现，返回-1

lastIndexOf('' | "" ,[int formIndex] ) 从formIndex开始查找最后一次出现的位置

contains(String str); 查找是否包含某个子串

        String s1 ="明月明月奈何明月照沟渠";
        //index0f('’/"")查找某个字符|字符串首次出现的下标位置，如果未出现，返回值为-1
        // indexOf(''/"",int index)
//        int index1=s1.indexOf('我');
        int index1=s1.indexOf('我',7);//从下表7开始查找
        System.out.println("字符‘我’的下标为："+index1);
        int index2=s1.indexOf("明月"); //查找字符串的下标
        System.out.println("字符串明月的下标为："+index2);

        //lastIndexOf('' | "" )查找某个字符|字符串最后一次出现的下标位置，如果未出现，返回-1
        //lastIndexOf('' | "" ,[int formIndex] ) 从formIndex开始查找最后一次出现的位置
        int index3=s1.lastIndexOf('明');//查找最后一次出现的 明 的下标
        System.out.println("最后一次出现字符‘明’的下标为："+index3);
        int index4=s1.lastIndexOf("明月");//查找最后一次出现的 明月 的下标
        System.out.println("最后一次出现字符串明月的下标为："+index4);

        //查找是否包含某个子串
        boolean b1 =s1.contains("明月");
        System.out.println(b1);

四、数组（引用数据类型）

1.定义：数组的声明：数据类型[ ] 数组名; 或数据类型数组名[ ];

int arr1[];
int[] arr2;

2 初始化：

（1）动态初始化：

数据类型[ ] 数组名=new 数据类型[长度]

（2）静态初始化：

数据类型[ ] 数组名=new 数据类型[]{元素1、元素2、元素3、}

（3）静态省略初始化：

数据类型[ ] 数组名={元素1、元素2、元素3、}

//1. 动态初始化： 数据类型[] 数组名=new 数据类型[长度]
int[] arr3=new int[5];
//2.静态初始化： 数据类型[] 数组名=new 数据类型[]{元素1、元素2、元素3、}
String[] names=new String[]{"张三","李四","王五"};
//3.静态省略初始化： 数据类型[] 数组名={元素1、元素2、元素3、}
String[] name1={"张三","李四","王五"};

动态初始化应用：

 //动态初始化
  //声明和初始化同时操作
  double[] scores_1=new double[10];
  //先声明后初始化
  double[] scores_2;
  scores_2=new double[10];
  //取值 ： 数据类型 变量名=数组名[下标]
  double score1=scores_1[0];
  System.out.println("第一个元素为："+score1);
  //赋值： 数组名[下标]=值
  scores_1[0]=98;
  System.out.println("第一个元素"+scores_1[0]);//98
  System.out.println("第一个元素为："+score1);//结果为0.0

静态初始化应用：

  //2.静态初始化
//声明利初始化同时操作
  int[] nums = new int[]{34,43,12,56,78};System.out.println(nums);
  nums[2]= 666;//重新赋值
  System.out.println(Arrays.toString(nums));
 //先声明，后初始化同时操作
  int[] nums2;
  nums2 = new int[]{78,89,12};
  System.out.println("地址:"+nums2);
  System.out.println("长度:"+nums2.length);
  System.out.println(Arrays.toString(nums2));

静态省略初始化应用：

 //3.静态省略初始化
  //声明利赋信同时操作
  int[] nums3 ={34,43,12,56,78};
  System.out.println(nums3);
  System.out.println("nums3的内容:"+Arrays.toString(nums3));
  //静态省略初始化，不允许先声明后赋值
  // int[] nums4:
  // nums4={34,43,12,56,78};

3. 数组的应用

 String[] names = {"张三","里斯","王麻子","王五","小红","小兰"};
  System.out.println("首元素:"+names[0]);
  System.out.println("尾元素:"+names[names.length-1]);System.out.println("交换前:"+ Arrays.toString(names));
   //首尾元素交换
  String temp = names[0];
  names[0]= names[names.length-1];
  names[names.length-1]= temp;
  System.out.println("交换后:"+ Arrays.toString(names));
int[] arr1=new int[5];
System.out.println("整型数组："+arr1);  // 打印地址
System.out.println(Arrays.toString(arr1));  // 结果 0，0，0，0，0

double[] arr2=new double[5];
System.out.println("浮点型数组："+arr2);
System.out.println(Arrays.toString(arr2));  //默认0.0

char[] arr4=new char[5];
System.out.println("字符型数组："+arr4);
System.out.println(Arrays.toString(arr4));  //默认  不可见字符

boolean[] arr5=new boolean[5];
System.out.println("布尔型数组："+arr5);
System.out.println(Arrays.toString(arr5));  //默认 false

String[] arr6=new String[5];
System.out.println("整型数组："+arr6);
System.out.println(Arrays.toString(arr6));   //默认 null

练习：

1.请编写程序，判断指定字符是大写字母还是小写字母

//字符类型的变量c，保存任意英文字母
        char c = 'E';
        // 请补充代码，完成判断变量c中所保存的字符是大写字母还是小写字母
        // 按照格式输出：字符xxx是大(小)写字母

        String str1 = 'A' <= c && c <= 'Z' ? "大写" : ('a' <= c && c <= 'z' ? "小写" : "不是字符");
        System.out.println("字符" + c + "是" + str1 + "字符");

2.请编写程序，完成3个变量的升序排列，输出最大值、最小值、中间值以及升序排列结果

// 请补充代码，完成变量x、y、z的升序排列

        int x = 12, y = 8, z = 39;
        int max=x>y?(x>z?x:z):(y>z?y:z);
        int min=x<y?(x<z?x:z):(y<z?y:z);
        int sum= x!=max&x!=min? x:(y!=max&& y!=min? y:z);
        System.out.println("最大值："+max+"  中间值："+sum+"  最小值："+min);

3. 请编写程序：判断是什么邮箱

提供了字符串email，此字符串存储邮箱，请判断email是否是邮箱(是邮箱的标志为有符号)，如果是邮箱，请判断是qq邮箱还是163邮箱(判断准为@后的内容为qq.com163.com)假设只有这两种邮箱。如果不是邮箱，输出不是邮箱，如果是邮箱，输出是QQ邮箱，否则输出是163邮箱

String email="x18372186899@163.com";
int boo1 =email.indexOf("@");
String boo2= boo1>-1? ("qq.com".equals(email.substring(boo1))?"QQ邮箱":"163邮箱"):"不是邮箱";
System.out.println(boo2);