比如abcdefgabdef
其中字符c和g不重复，返回c的小标，下标从0开始，那么是2
package com.example.demo;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.LinkedHashSet;
public class Test111 {
String str1 = "abcdefgabdef";
@Test
public void fun1(){
//LinkedHashSet  有序的set集合
LinkedHashSet once = new LinkedHashSet<>();
LinkedHashSet chongFu = new LinkedHashSet<>();
ArrayList list = new ArrayList<>();
for (int i = 0; i < str1.length(); i++) {
boolean add = once.add(str1.charAt(i)); // 得到集合里所有出现过一次的元素
if (!add) {
chongFu.add(str1.charAt(i));// 得到集合里重复出现的元素
}
}
boolean removeAll = once.removeAll(chongFu); // once里将存储所有不重复的元素
list.addAll(once);
System.out.println("所有不重复的字母:" + list);
for (int i = 0; i < str1.length(); i++) {
if (list.get(0) == str1.charAt(i)) {
System.out.println("它的索引为:" + i);
}
}
}
@Test
public void fun2(){
ArrayList list = new ArrayList<>();
for (int i = 0; i < str1.length(); i++) {
int flag = -1;// 定义一个标志
for (int j = 0; j < str1.length(); j++) {
if (i == j) {// 如果是同一个元素跳过本次循环,继续下次循环
continue;
}
// 如果这个元素不是第一次出现,将标志改变
if (str1.charAt(i) == str1.charAt(j)) {
flag = 1;
}
}
// 未改变标志的元素,即只出现一次的元素
if (flag == -1) {
list.add(str1.charAt(i));
} // if
} // for
System.out.println("所有不重复的字母:" + list);
System.out.println("第一个不重复的字母为:" + list.get(0));
for (int i = 0; i < str1.length(); i++) {
if (list.get(0) == str1.charAt(i)) {
System.out.println("它的索引为:" + i);
}
}
}
@Test
public void fun3(){
for (int i = 0; i < str1.length(); i++) {
char charAt = str1.charAt(i);
// 找出取出的元素第一次出现的位置
int indexOf = str1.indexOf(charAt);
// 找出取出的元素最后一次出现的位置
int lastIndexOf = str1.lastIndexOf(charAt);
// 如果是唯一的元素,第一次出现的位置和最后一次出现的位置应该相同
// 如果相同了就没必要在继续走for循环了
if (indexOf == lastIndexOf) {
System.out.println(str1.charAt(indexOf));
System.out.println(indexOf);
return;
}
}
}
}
BF算法
BF算法，即Brute Force 算法的简称。用于检测某个字符串是否是另一个字符串的子串。
子串的概念#
假设字符串 X = ‘girlfriend‘ , Y = ‘friend‘ ，那么Y 就是 X的子串。同样的，end是friend的子串。
BF算法的思路#
BF算法的思路非常简单粗暴，就是从前到后一点点的匹配。例如： 子串 x= abcd | 主串为 y = abdabceabcde
如果 x[0] = y[0] 继续比较 x[1] y[1] 继续下去，如果一直到 x[3]= y[3]时 则 x 整个串都匹配上了。
如果 x[0] = y[0] 继续比较 x[1] y[i] 发现不等，那么就开始用 x[0] 比较 y[1] 然后继续 x[1] y[2]。
public class TestBF {
public static void main(String[] args) {
System.out.println(isSubstring("abdabceabcde","abcd")); // true
System.out.println(isSubstring("abdabceabcde","ff"));   // false
}
private static boolean isSubstring(String main,String sub){
if(main == null || sub == null) {
return false;
}
if(main.length() < sub.length()) { // 子串不可比主串长
return false;
}
if(main.equals(sub)) { // 主串，子串 相等的情况
return true;
}
int len = main.length() - sub.length();
for (int i = 0; i < len; i++) {
boolean match = true;
for (int j = 0; j < sub.length(); j++) {
if(main.charAt(i+j) != sub.charAt(j)) {
match = false;
break;
}
}
if(match) {
return true;
}
}
return false;
}
}
原文：https://www.cnblogs.com/qianjinyan/p/10823525.html

substr 下标从0 开始

instr 返回的数值，从1开始

 

oracle字符串处理

select substr(memo,instr(memo,'hourid=',1)+1,instr(memo,'&',instr(memo,'=',1)+1)-instr(memo,'=',1)-1) from ZCSTATITEM t where memo is not null and memo like'%hourid%' and substr(memo,instr(memo,'&',1)+1,instr(memo,'&',instr(memo,'&',1)+1)-instr(memo,'&',1)-1) is not null

 

 

select t.memo, substr(memo,instr(memo,'=',1,2)+1,instr(memo,'&',1,2)) from ZCSTATITEM t where memo is not null and memo like '%hourid%'

select substr(memo,instr(memo,'=',2),4) from ZCSTATITEM

 

--   CA-CA1344-A-11OCT141250-D

select instr('CA-CA1344-A-11OCT141250-D','-',1,1) from dual;  

select instr('CA-CA1344-A-11OCT141250-D','-',instr('CA-CA1344-A-11OCT141250-D','-',1)+1)-instr('CA-CA1344-A-11OCT141250-D','-',1)-1 from dual

 

 

select substr(name,instr(name,'-',1)+1,instr(name,'-',instr(name,'-',1)+1)-instr(name,'-',1)-1) from dual;  

 

select substr(name,instr(name,'-',1,1)+1,instr(name,'-',1,2)-1-instr(name,'-',1,1)) from dual; 

 

例子

CA-CA1344-A-11OCT141250-D

select substr(name,instr(name,'-',1)+1,instr(name,'-',instr(name,'-',1)+1)-instr(name,'-',1)-1) from test;  

select substr(name,instr(name,'-',1,1)+1,instr(name,'-',1,2)-1-instr(name,'-',1,1)) from test;  

六：接下我们再写一下，取第二个"-"到第三个"-"之间的字符串的方法：

select substr(name,instr(name,'-',2,2)+1,instr(name,'-',2,3)-1-instr(name,'-',2,2)) from test;  

在讨论数组下标为什么从0开始之前我们先回顾一下数组有什么特点。

数组优点：

1.内存中占据连续的内存空间

2.数据随机访问，也就是说获取数据非常高效

那为什么说数组的数据可以随机访问而且取数据非常高效呢？

下面我们来看这样一张图：



上图是一个长度为10的整型数组，我们假设数组的首地址是1000。不难看出当下标从0开始的时候，数组中各个元素的首地址计算公式是：

a[i]地址 = 1000 + i*4。（其中1000是数组a的首地址，4是每个元素占的内存大小（int占4个字节大小）。）

可以看的出数组中根据下标随机访问的时间复杂度为O（1）非常高效。
如果下标从1开始会怎么样呢？计算公式如下：

a[i]地址 = 1000 + (i-1)*4。

可以看的出下标从1开始比下标从0开始多了一个减法运算(即：i-1)。虽然我们口算一下感觉很简单，但是在cpu中需要转化成2进制，通过好几条指令来运算才能得到结果。
试想一下，数组作为非常底层的一个数据结构，它的运算是要保证非常高效的，怎么可能多花费一次运算呢？所以数组的下标是从0开始，而不是从1开始。
当然这只是我个人的一种观点，如果大家有更好的观点，可以留言讨论一下。
好了，今天就说到这吧，希望对大家有所帮助。



欢迎关注我的微信号，我会持续的更新数据结构的相关内容，并领取很多视频学习资料。

扫二维码关注公众号【Java程序员的奋斗路】可领取如下:

1.学习资料： 1T视频教程（大约有100多个视频）：涵盖Javaweb前后端教学视频、机器学习/人工智能教学视频、Linux系统教程视频、雅思考试视频教程，android.等

2.项目源码：20个JavaWeb项目源码。

关于数组的下标从0开始的问题
通过大二上学期的这门数据结构课，关于线性表（也可以认为是数组）的下标什么时候从0开始，什么时候从1开始有了如下简单的归纳，希望在以后的学习中可以进行再归纳

当在操作的时候需要存储一些临时元素时，这时下标从1开始存储，0号单元用来存储临时元素

如在进行直接插入排序时将 r[0] 处设为监视哨，存放当前需要比较的记录的关键字。

又比如在QickSort中的Partition改进算法中，将枢轴记录暂存在 r[0]。

当对线性表进行操作时，用到了循环的问题。

比如循环队列，和2-路插入排序。

可能这样的话可以通过直接对某个数据的位置运算后的位置取余（直接 mod 空间的大小）