0:00:00.956,0:00:04.067
Até agora, nós escrevemos um código que, quando[br]há um caso de teste. E se o teste é

0:00:04.067,0:00:08.096
verdade, imprima a linha de dados. Assim, nesta seção curta[br]Eu quero mostrar como,

0:00:08.096,0:00:13.037
em vez disso, você acabou de contar o número[br]de linhas, no caso de o teste é verdadeiro. E

0:00:13.037,0:00:17.062
isto é, que é mais parecido com o que realmente queremos fazer[br]com computadores. Assim, em

0:00:17.062,0:00:21.096
para fazer isso, teremos que adicionar um código[br]romance no código ter sido

0:00:21.096,0:00:26.000
fazer. Portanto, descrito aqui, mas I,[br]Vou apontar as partes do presente Código

0:00:26.000,0:00:30.039
exemplo. Portanto, há três coisas que têm[br]acrescentado para contar. Uma delas é que sou

0:00:30.039,0:00:34.058
irá introduzir uma nova variável, eu vou ter a certeza[br]chamar contar. E eu sou apenas

0:00:34.058,0:00:38.051
Eu redefini-la, e eu faço[br]que, antes do ciclo começa a operar. Assim,

0:00:38.051,0:00:43.015
Count é zero. Em seguida, dentro do ciclo[br]Dentro do comando if, onde

0:00:43.015,0:00:48.015
Eu sei, eu, eu posso imprimir a linha como fizemos muitas vezes antes[br]. Mas então eu também

0:00:48.015,0:00:52.090
tem esse código, contador = contador + 1. E isso é uma espécie de aparência incomum

0:00:52.090,0:00:57.046
linha. Vou dizer-lhe que ele faz. Ele[br]qualquer valor que é armazenado no interior da conta

0:00:57.046,0:01:02.000
é aumentado em um. Portanto, em[br]explode cinco ou seis, ou 10:50,

0:01:02.000,0:01:06.048
Ou o que quer. Mas deixe-me, deixe-me explicar[br]como isso funciona. Assim, na matemática, este

0:01:06.048,0:01:10.096
linha realmente não faz sentido. Como,[br]você sabe, o valor é igual a si mesmo

0:01:10.096,0:01:15.094
mais um. Mas a razão que esta trabalha no computador[br]função é a de igualdade

0:01:15.094,0:01:20.048
sinal de código de computador é[br]realmente mais simples do que em matemática. Eo

0:01:20.048,0:01:25.013
O importante aqui é entender que[br]primeiro avalia a mão direita. E, em seguida

0:01:25.013,0:01:29.046
apenas uma vez que é resolvida para obter um valor de[br], Então este valor é armazenado no

0:01:29.046,0:01:33.084
variável no lado esquerdo. Então, imagine[br]a primeira vez que é executado. Então, o que importa

0:01:33.084,0:01:38.018
zero e, em seguida, torna-se a esta linha. Assim, o primeiro[br]que vai fazer é avaliar

0:01:38.018,0:01:42.036
do lado direito. Assim, a contagem é zero, então[br]zero mais um é igual a um. Assim, irá, este

0:01:42.036,0:01:46.054
pilha é também um. Assim, uma vez que estima-se que[br]fora, é armazenada em uma conta do que é hoje

0:01:46.054,0:01:50.087
contagem é um deles. Assim você pode ver lá onde a ação[br]entrada na linha

0:01:50.087,0:01:54.093
a contagem foi de saídas de zero e então[br]é um. Portanto, até que solavancos. Em seguida, o

0:01:54.093,0:01:59.009
Da próxima vez que você vê esta linha, se o. Se afirmação é verdadeira Pouco valor para

0:01:59.009,0:02:03.064
do lado direito contado como um. Assim, uma[br]mais um é dois, por isso depois de descobrir

0:02:03.064,0:02:08.009
Que é a de que dois dos quais são armazenados na contagem de dois[br]que agora tem dois aspectos. Portanto

0:02:08.009,0:02:12.094
em última análise, é necessário dispor de um comando das[br]os detalhes dessa coisa, você

0:02:12.094,0:02:17.033
só precisa saber que a forma, x = x +1[br]de algumas variáveis, apenas pedras que

0:02:17.033,0:02:22.056
uma, cada vez sua carreira. Então eu estava dizendo[br]Existem três partes. Nós estabelecemos

0:02:22.056,0:02:27.078
zero e contador = contador 1[br]dentro da instrução if e então, finalmente, nós, nós

0:02:27.078,0:02:33.019
apenas imprimir o valor que permanece no[br]Na conta depois de tudo, após o

0:02:33.019,0:02:39.046
Para loop-foi executado através de todos os tempos. Então, vamos tentar isso.[br]Então, se eu executar este. O que vemos é que o

0:02:39.046,0:02:44.019
loop é executado, e se a declaração aqui, verifica[br]por nomes que começam com "A". Portanto, nós

0:02:44.019,0:02:48.098
basta ver todas essas "A" de nomes. E, em seguida, para baixo[br]no final, há uma única linha ", diz: 258"

0:02:48.098,0:02:54.012
Então, o que mostra é o loop for, você sabe, a contagem começou a

0:02:54.012,0:02:58.073
zero. O laço para funcionou todas as vezes. A instrução if[br]era verdade, aparentemente, 258

0:02:58.073,0:03:03.062
vezes fora de 2.000 vezes. E, em seguida[br]obter esse "count: 258". As impressões

0:03:03.062,0:03:08.015
Devido a esta linha, portanto, que há[br]após o loop é feita, de modo a que tudo o que estes

0:03:08.015,0:03:12.080
impressões internas são feitas. Ok, então eu[br]faça algumas experiências aqui, então um simples

0:03:12.080,0:03:17.027
coisa a fazer é como, bem que se eu[br]eliminar esta impressão que está dentro do loop?

0:03:17.027,0:03:21.081
Portanto, eu ainda estou indo para percorrer as linhas,[br]eu ainda tenho a declaração se, mas depois o

0:03:21.081,0:03:25.096
A única coisa que acontece dentro da instrução if é contador = contador +1.

0:03:25.096,0:03:30.061
Então, eles correm em um. Então, agora se eu[br]executar este programa. Eu só, eu só tenho esse

0:03:30.061,0:03:35.079
A linha de partida. Eu corro e só[br]diz, bam, 258. Então, isso está começando, este

0:03:35.079,0:03:39.070
está começando a se parecer mais com o que consideramos[br]com, você sabe, como

0:03:39.070,0:03:43.087
equipe está tendo algum[br]Dados de massa e do tipo de rastreio através dele e dando

0:03:43.087,0:03:47.090
== Um tipo de uma resposta definitiva. Ok,[br]Portanto, vamos tentar, tentar alguns problemas aqui.

0:03:47.090,0:03:52.002
E nós manual, temos a variável[br]soluções. Quantos nomes começam com "X" e

0:03:52.002,0:03:56.019
é então comparada com a quantidade de começar com "Y".[br]Portanto, se você quiser dizer-lhe quantos nomes começando

0:03:56.019,0:03:59.074
com "X", que acaba de mudar, você sabe, o número[br]Ea contagem é igual a mais um.

0:03:59.074,0:04:03.062
Contador = contador que eu puder[br]manter. Então, eu acabei de dizer, quantas casa

0:04:03.062,0:04:07.040
com "X"? Então, se eu executá-lo, digamos, seis anos.[br]Então, agora ele diz oh bem o que se eu quiser

0:04:07.040,0:04:11.052
Para descobrir quantos começam com "Y", para que você possa ver todos[br]Toda a estrutura é mantida e

0:04:11.052,0:04:16.014
Eu só tenho que mudar isso uma coisa é "Y".[br]E os seus dezessete anos, então eu acho mais nomes

0:04:16.014,0:04:21.026
começando com "Y", mais nomes começam com[br]"Y" com "X". Então ele diz, para o terceiro

0:04:21.026,0:04:26.009
um, quantos nomes de meninas que começam com "A",[br]em seguida, mudar para contar quantos nomes de criança

0:04:26.009,0:04:30.096
começando com "A". Ok então isso vai trazer[br]material da última vez, eu

0:04:30.096,0:04:39.029
quero para usar uma e aqui. Então eu digo,[br]startsWith ("A"). Eu vou dizer e ("&&") row.getField ("gender") "menina"

0:04:39.029,0:04:47.014
Então, isso é[br]a tarefa e, em seguida, dentro de apenas me disse

0:04:47.014,0:04:55.048
contador = contador +1. Ok, 161[br]nove, portanto, a pergunta de follow-up é

0:04:55.079,0:05:04.014
quantos nomes de menino. Assim, por pequeno que apenas[br]mudar isso. Então, essa noção de se

0:05:04.014,0:05:10.019
E a tarefa é realmente o mesmo para a contagem[br]. É realmente apenas onde, como temos

0:05:10.019,0:05:16.002
que iria imprimir (linha), agora eu tenho apenas este 1[br]contador = contador que você pode fazer a contagem.

0:05:16.002,0:05:21.016
[Inaudível] para que os nomes crescer[br][Inaudível]. Bem, assim é o nosso primeiro

0:05:21.016,0:05:25.000
pesquisar a conta básica. Então, vamos tentar alguns exercícios[br].